NAME

       XML::Filter::Tee - Send SAX events to multiple processor, with switching

VERSION

       version 0.46

SYNOPSIS

           my $t = XML::Filter::Tee->new(
               { Handler => $h0 },
               { Handler => $h1 },
               { Handler => $h2 },
               ...
           );

           ## Altering the handlers list:
           $t->set_handlers( $h0, $h1, $h2, $h3 );

           ## Controlling flow to a handler by number and by reference:
           $t->disable_handler( 0 );
           $t->enable_handler( 0 );

           $t->disable_handler( $h0 );
           $t->enable_handler( $h0 );

           ## Use in a SAX machine (though see L<XML::SAX::Pipeline> and
           ## L<XML::SAX::Tap> for a more convenient way to build a machine
           ## like this):
           my $m = Machine(
               [ Intake => "XML::Filter::Tee" => qw( A B ) ],
               [ A      => ">>log.xml" ],
               [ B      => \*OUTPUT ],
           );

DESCRIPTION

       XML::Filter::Tee is a SAX filter that passes each event it receives on to a list of
       downstream handlers.

       It's like XML::Filter::SAXT in that the events are not buffered; each event is sent first
       to the tap, and then to the branch (this is different from XML::SAX::Dispatcher, which
       buffers the events).  Unlike XML::Filter::SAXT, it allows it's list of handlers to be
       reconfigured (via "set_handlers") and it allows control over which handlers are allowed to
       receive events.  These features are designed to make XML::Filter::Tee instances more
       useful with SAX machines, but they to add some overhead relative to XML::Filter::SAXT.

       The events are not copied, since they may be data structures that are difficult or
       impossibly to copy properly, like parts of a C-based DOM implementation.  This means that
       the handlers must not alter the events or later handlers will see the alterations.

NAME

       XML::Filter::Tee - Send SAX events to multiple processor, with switching

METHODS

       new
               my $t = XML::Filter::Tee->new(
                   { Handler => $h0 },
                   { Handler => $h1 },
                   { Handler => $h2 },
                   ...
               );

       set_handlers
               $t->set_handlers( $h0, $h1, $h2 );
               $t->set_handlers( {
                       Handler => $h0,
                   },
                   {
                       Handler => $h1,
                   },
               );

           Replaces the current list of handlers with new ones.

           Can also name handlers to make enabling/disabling them by name easier:

               $m->set_handlers( {
                       Handler => $validator,
                       Name    => "Validator",
                   },
                   {
                       Handler => $outputer,
                   },
               );

               $m->disable_handler( "Validator" );

       disable_handler
               $t->disable_handler( 0 );            ## By location
               $t->disable_handler( "Validator" );  ## By name
               $t->disable_handler( $h0 );          ## By reference

           Stops sending events to the indicated handler.

       enable_handler
               $t->enable_handler( 0 );            ## By location
               $t->enable_handler( "Validator" );  ## By name
               $t->enable_handler( $h0 );          ## By reference

           Stops sending events to the indicated handler.

AUTHOR

           Barrie Slaymaker <barries@slaysys.com>

COPYRIGHT

           Copyright 2002, Barrie Slaymaker, All Rights Reserved

       You may use this module under the terms of the Artistic, GNU Public, or BSD licenses, as
       you choose.

AUTHORS

       •   Barry Slaymaker

       •   Chris Prather <chris@prather.org>

COPYRIGHT AND LICENSE

       This software is copyright (c) 2013 by Barry Slaymaker.

       This is free software; you can redistribute it and/or modify it under the same terms as
       the Perl 5 programming language system itself.