File Coverage

blib/lib/XML/Filter/Distributor.pm

Criterion	Covered	Total	%
statement	65	71	91.5
branch	8	10	80.0
condition	5	12	41.6
subroutine	12	14	85.7
pod	5	7	71.4
total	95	114	83.3

package XML::Filter::Distributor;
{
  $XML::Filter::Distributor::VERSION = '0.46';
}
# ABSTRACT: Multipass processing of documents


use XML::SAX::Base;

@ISA = qw( XML::SAX::Base );


@EXPORT_OK = qw( Distributor );

use strict;
use Carp;
use XML::SAX::EventMethodMaker qw( sax_event_names missing_methods compile_methods );


sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;
    my $self = bless {}, $class;

    $self->{Channels} = [];

    for ( @_ ) {
        push @{$self->{Channels}}, $_;
    }

    return $self;
}


sub set_handlers {
    my $self = shift;
    @{$self->{Channels}} = map { { Handler => $_ } } @_;
}


sub set_handler {
    shift()->set_handlers( @_ );
}


sub _buffer {
    my $self = shift;
    push @{$self->{BUFFER}}, [ @_ ];
}

sub set_aggregator {
    my $self = shift;
    $self->{Aggregator} = shift;
}


sub get_aggregator {
    my $self = shift;

    return $self->{Aggregator};
}


sub _change_channels {
    my $self = shift;

    my ( $desired_channel ) = @_;
    $desired_channel = $self->{CurChannelNum} + 1
        unless defined $desired_channel;
    $desired_channel = undef
        if $desired_channel < 0 || $desired_channel > $#{$self->{Channels}};

    ## Mess with XML::SAX::Base's internals a bit (ugh).
    ## TODO: Get less messy when the X::S::B in CVS makes it in to the
    ## real world.
    $self->{Methods} = {};
    $self->{Handler} = undef;

    if ( defined $desired_channel ) {
        $self->{CurChannel} = $self->{Channels}->[$desired_channel];
        $self->{$_} = $self->{CurChannel}->{$_}
            for keys %{$self->{CurChannel}};
    }

    $self->{CurChannelNum} = $desired_channel;
    return $desired_channel;
}


sub _replay {
    my $self = shift;

    my $r;
    for ( @{$self->{BUFFER}} ) {
        my $event = shift @$_;
        ## This is ugly, must be a faster way, too tired to think of one.
        my $meth = "SUPER::$event";
        $self->$meth( @$_ );
        unshift @$_, $event;
    }

    return $r;
}


sub start_document {
    my $self = shift;

    @{$self->{BUFFER}} = ();
    $self->_buffer( "start_document", @_ );

    $self->_change_channels( 0 );

    my $aggie = $self->get_aggregator;
    $aggie->start_manifold_document( @_ )
        if $aggie && $aggie->can( "start_manifold_document" );

    return $self->SUPER::start_document( @_ );
}


sub end_document {
    my $self = shift;

    $self->_buffer( "end_document", @_ );

    $self->SUPER::end_document( @_ );

    $self->_replay
        while $self->_change_channels;

    @{$self->{BUFFER}} = ();

    my $aggie = $self->get_aggregator;
    return $aggie->end_manifold_document( @_ )
        if $aggie && $aggie->can( "end_manifold_document" );

    return ;
}

compile_methods __PACKAGE__, <<'TPL_END', missing_methods __PACKAGE__, sax_event_names ;
sub  {
    my $self = shift;
    $self->_buffer( "", @_ );
    return $self->SUPER::( @_ );
}
TPL_END





1;

__END__