File Coverage

blib/lib/Iterator/File.pm

Criterion	Covered	Total	%
statement	88	96	91.6
branch	13	20	65.0
condition	1	2	50.0
subroutine	20	22	90.9
pod	6	12	50.0
total	128	152	84.2

package Iterator::File;

## $Id: File.pm,v 1.14 2008/06/18 06:46:27 wdr1 Exp $

use 5.006;
use strict;
use warnings;

use Carp;
use IO::File;
use Data::Dumper;

use Iterator::File::Utility;
use Iterator::File::Status;

require Exporter;

our @ISA = qw(Exporter Iterator::File::Utility);

our @EXPORT = qw(
  iterator_file
);

our $VERSION = substr(q$Revision: 1.14 $, 10);

use overload '""' => \&overload_as_string,
  '+' => 'overload_add';

my %default_config =
  (
   'chomp'                      => 1,
   'source_class'               => 'Iterator::File::Source::FlatFile',
   'state_class_without_resume' => 'Iterator::File::State::Interface',
   'state_class_with_resume'    => 'Iterator::File::State::TempFile',
   'resume'                     => 0,
   'repeat_on_resume'           => 1,
   'verbose'                    => 0,
   'status'                     => 0,
  );



sub iterator_file {
  my ($filename, %config) = @_;

  croak("No file name given to iterator_file!") unless (defined($filename));
  my $iterator = new Iterator::File( %config,
                                     'filename' => $filename
                                     );
  return $iterator;
}



sub new {
  my ($class, %config) = @_;

  %config = (%default_config, %config);
  ## What type of default state class do we use?
  ## Make sure we respect any explicit input from the user.
  unless (defined $config{'state_class'}) {
    if ($config{'resume'}) {
      $config{'state_class'} = $config{'state_class_with_resume'};
    } else {
      $config{'state_class'} = $config{'state_class_without_resume'};
    }
  }

  my $self = $class->SUPER::new( %config );
  bless(\%config, $class);

  ## Instatiate the needed objects...
  my $source_class = $config{'source_class'};
  my $state_class  = $config{'state_class'};

  $self->_lazy_load_module( $source_class );
  $self->_lazy_load_module( $state_class );

  $self->{'source_object'} = $source_class->new( %config );
  $self->{'state_object'}  = $state_class->new( %config );

  ## Do we care about status?
  if ($self->{'status'}) {
    $self->{'status_object'} = Iterator::File::Status->new( %config );
  }

  $self->initialize();

  return $self;
}



sub initialize {
  my ($self) = @_;

  $self->{'source_object'}->initialize();
  $self->{'state_object'}->initialize();

  ## Pickup where we left off...
  if ($self->{resume}) {
    $self->{source_object}->advance_to( $self->{'state_object'}->marker() );
  }
}



sub next {
  my ($self) = @_;

  my $state  = $self->{'state_object'};
  my $source = $self->{'source_object'};

  if ( $self->{repeat_on_resume} ) {
    $state->advance_marker();
  }

  my $next_data = $source->next();

  if ( !$self->{repeat_on_resume} ) {
    $state->advance_marker();
  }

  unless ( defined($next_data) ) {
    ## All done
    $self->_verbose( "Finished.  Cleaning up..." );
    $state->finish();
    $source->finish();
  } else {
    if ($self->{'status'}) {
      my $marker = $self->{'state_object'}->marker();
      $self->{'status_object'}->emit_status( $marker );
    }
  }

  return $next_data;
}



sub skip_next {
  my ($self, $num) = @_;

  $num ||= 1;
  while ($num--) {
    $self->next();
  }

  return $self->value();
}



sub value {
  my ($self) = @_;

  return $self->{'source_object'}->value();
}



sub finish {
  my ($self) = @_;

  $self->{'source_object'}->finish();
  $self->{'state_object'}->finish();
}



sub state_object {
  my ($self) = @_;

  return  $self->{'state_object'};
}



sub source_object {
  my ($self) = @_;

  return  $self->{'source_object'};
}



sub emit_status {
  my ($self) = @_;
}



sub _lazy_load_module {
  my ($self, $module, @module_args) = @_;

  $self->_debug( "Loading '$module'... ");
  eval "require $module";
  if ($@) {
    confess ("Unable to load '$module': $@!");
  }

  $module->import( @module_args );
}



sub overload_as_string {
  my ($self) = @_;

  return $self->value();
}



sub overload_add {
  my ($self, $num) = @_;

  $self->skip_next($num);

  return $self;
}

1;
__END__