Data-Stag

 view release on metacpan or  search on metacpan

Data/Stag.pm  view on Meta::CPAN

Generates indent format from events

=back

All the above are kinds of L<Data::Stag::Writer>

=head3 chainhandler

       Title: chainhandler

        Args: blocked events - str or str[]
              initial handler - handler object
              final handler - handler object
     Returns: 
     Example: $h = Data::Stag->chainhandler('foo', $processor, 'xml')

chains handlers together - for example, you may want to make
transforms on an event stream, and then pass the event stream to
another handler - for example, and xml handler

  $processor = Data::Stag->makehandler(

Data/Stag.pm  view on Meta::CPAN

                                                },
				       b => sub { my ($self,$stag) = @_;
						  $stag->set_blah("eek");
                                                  return $stag
                                                },
                                       );
  $chainh = Data::Stag->chainhandler(['a', 'b'], $processor, 'xml');
  $stag = Data::Stag->parse(-str=>"(...)", -handler=>$chainh)

If the inner handler has a method CONSUMES(), this method will
determine the blocked events if none are specified.

see also the script B<stag-handle.pl>


=head2  RECURSIVE SEARCHING


=head3 find (f)

       Title: find

Data/Stag/ChainHandler.pm  view on Meta::CPAN

    my $self = shift;
    return;
}

sub subhandlers {
    my $self = shift;
    $self->{_subhandlers} = shift if @_;
    return $self->{_subhandlers};
}

sub blocked_event {
    my $self = shift;
    if (@_) {
        my $e = shift;
        $self->{_blocked_event} = $e;
        unless (ref($e)) {
            $e = [$e];
        }
        my %h = map {$_=>1} @$e;
        $self->blocked_event_h(\%h);
    }
    return $self->{_blocked_event};
}

sub blocked_event_h {
    my $self = shift;
    $self->{_blocked_event_h} = shift if @_;
    return $self->{_blocked_event_h};
}

sub is_blocked {
    my $self = shift;
    my $e = shift;
    if (!$e) {
        $self->throw("must pass arg to is_blocked");
    }
    my $is = $self->blocked_event_h->{$e};
    return $is;
}

sub start_event {
    my $self = shift;
    my $ev = shift;
    my $stack = $self->elt_stack;
    push(@$stack, $ev);

    my $sh = $self->subhandlers;
    my $is_blocked = grep {$self->is_blocked($_)} @$stack;
    if ($is_blocked) {
        $sh->[0]->start_event($ev);
    }
    else {
        foreach (@$sh) {
            $_->start_event($ev);
        }
    }
}

sub evbody {
    my $self = shift;
    my $ev = shift;
    my @args = @_;

    my $stack = $self->elt_stack;

    my $sh = $self->subhandlers;
    if (grep {$self->is_blocked($_)} @$stack) {
        $sh->[0]->evbody($ev, @args);
    }
    else {
        foreach (@$sh) {
            $_->evbody($ev, @args);
        }
    }
    
    return;
}

Data/Stag/ChainHandler.pm  view on Meta::CPAN

    my $stack = $self->elt_stack;
    $ev = pop @$stack;
    if (!$ev) {
        $self->throw("no event name on stack");
    }

    my $sh = $self->subhandlers;


    my $inside_blocked = grep {$self->is_blocked($_)} @$stack;
    if ($self->is_blocked($ev) &&
	!$inside_blocked) {

	# condition:
	# end of a blocked event, and we are 
	# not inside another blocked event
        my ($h, @rest) = @$sh;

        my @R = $h->end_event($ev);
        foreach my $handler (@rest) {
	    if (@R) {
		$handler->event(@$_) foreach @R;
		@$_ = () foreach @R;
	    }
        }
        my $tree = $h->tree;
        $tree->free;
    }
    else {

        if (grep {$self->is_blocked($_)} @$stack) {
            $sh->[0]->end_event($ev);
        }
        else {
            foreach (@$sh) {
                $_->end_event($ev);
            }
        }
    }
}

Data/Stag/StagImpl.pm  view on Meta::CPAN

                               }
			       elsif (!$_) {
				   ()
			       }
                               else {
                                   # assume it is string specifying format
                                   _gethandlerobj($tree, -fmt=>$_)
                               }
                             } @sh
                          ]);
    $handler->blocked_event($block);

    # if no explicit blocked events set, then introspect
    # the subhandlers to see if they declare what they emit
    if (ref($block) && !@$block) {
        my @emits = map {$_->CONSUMES} @{$handler->subhandlers};
        $handler->blocked_event(\@emits);
    }
    return $handler;
}

sub transform {
    my $tree = shift;
    my @T = @_;
    my %trap_h = 
      map {
	  my ($from, $to) = @$_;

README  view on Meta::CPAN

    itext
        Generates indented text from events

    All the above are kinds of the Data::Stag::Writer manpage

   chainhandler

           Title: chainhandler

            Args: blocked events - str or str[]
                  initial handler - handler object
                  final handler - handler object
         Returns: 
         Example: $h = Data::Stag->chainhandler('foo', $processor, 'xml')

    chains handlers together - for example, you may want to make transforms
    on an event stream, and then pass the event stream to another handler -
    for example, and xml handler

      $processor = Data::Stag->makehandler(