File Coverage

blib/lib/Data/Flow.pm

Criterion	Covered	Total	%
statement	76	82	92.6
branch	24	32	75.0
condition			n/a
subroutine	8	9	88.8
pod	0	7	0.0
total	108	130	83.0

package Data::Flow;

use strict;
use vars qw($VERSION @ISA @EXPORT);

require Exporter;
require AutoLoader;

@ISA = qw(Exporter AutoLoader);
# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.
@EXPORT = qw(
);
$VERSION = '1.02';	# The only change 0.09 --> 1.02 is this line ;-)


# Preloaded methods go here.

sub new {
  die "Usage: new Data::Flow \$recipes" unless @_ == 2;
  my $class = shift;
  my $recipes = shift;
  $recipes = bless [$recipes, {}], $class;
  # $recipes->set(@_);
  $recipes;
}

sub set {
  my $self = shift;
  die "Odd number of data given to Data::Flow::set" if @_ % 2;
  my %data = @_;
  @{$self->[1]}{keys %data} = values %data;
}

sub unset {
  my ($self, $f) = shift;
  for $f (@_) {
    delete $self->[1]{$f}
  }
}

sub get {
  my $self = shift;
  my $request = shift;
  $self->request($request);
  $self->[1]->{$request};
}

sub aget {
  my $self = shift;
  [map { $self->request($_); $self->[1]->{$_} } @_]
}

sub already_set {
  my $self = shift;
  my $request = shift;
  exists $self->[1]->{$request};
}

sub request {
  my $self = shift;
  my ($recipes, $data) = @$self;
  my ($recipe, $request);
  for $request (@_) {
    # Bail out if present
    next if exists $data->{$request};
    $recipe = $recipes->{$request};
    # Get prerequisites
    $self->request(@{$recipe->{prerequisites}})
      if exists $recipe->{prerequisites};
    # Check for default value
    if (exists $recipe->{default}) {
      $data->{$request} = $recipe->{default};
      next;
    } elsif (exists $recipe->{process}) { # Let it do the work itself.
      &{$recipe->{process}}($data, $request);
      die "The recipe for processing the request `$request' did not acquire it"
	unless exists $data->{$request};
    } elsif (exists $recipe->{oo_process}) { # Let it do the work itself.
      &{$recipe->{oo_process}}($self, $request);
      die "The recipe for OO-processing the request `$request' did not acquire it"
       unless exists $data->{$request};
    } elsif (exists $recipe->{output}) { # Keep return value.
      $data->{$request} = &{$recipe->{output}}($data, $request);
    } elsif (exists $recipe->{oo_output}) { # Keep return value.
      $data->{$request} = &{$recipe->{oo_output}}($self, $request);
    } elsif (exists $recipe->{filter}) { # Input comes from $data
      my @arr = @{ $recipe->{filter} };
      my $sub = shift @arr;
      foreach (@arr) { $self->request($_) }
      @arr = map $data->{$_}, @arr;
      $data->{$request} = &$sub( @arr );
    } elsif (exists $recipe->{self_filter}) { # Input comes from $data
      my @arr = @{ $recipe->{self_filter} };
      my $sub = shift @arr;
      foreach (@arr) { $self->request($_) }
      @arr = map $data->{$_}, @arr;
      $data->{$request} = &$sub( $self, @arr );
    } elsif (exists $recipe->{method_filter}) { # Input comes from $data
      my @arr = @{ $recipe->{method_filter} };
      my $method = shift @arr;
      foreach (@arr) { $self->request($_) }
      @arr = map $data->{$_}, @arr;
      my $obj = shift @arr;
      $data->{$request} = $obj->$method( @arr );
    } elsif (exists $recipe->{class_filter}) { # Input comes from $data
      my @arr = @{ $recipe->{class_filter} };
      my $method = shift @arr;
      my $class = shift @arr;
      foreach (@arr) { $self->request($_) }
      @arr = map $data->{$_}, @arr;
      $data->{$request} = $class->$method( @arr );
    } else {
      die "Do not know how to satisfy the request `$request'"
	unless exists $data->{$request};	# 'prerequisites' could set it
    }
  }
}

*TIEHASH  = \&new;
*STORE	  = \&set;
*FETCH	  = \&get;

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__