File Coverage

blib/lib/XML/LibXML/Iterator.pm

Criterion	Covered	Total	%
statement	12	138	8.7
branch	0	58	0.0
condition	0	20	0.0
subroutine	4	22	18.1
pod	11	14	78.5
total	27	252	10.7

#
#
package XML::LibXML::Iterator;

use strict;

use XML::NodeFilter qw(:results);

use vars qw($VERSION);

$VERSION = '1.04';

use overload
  '++' => sub { $_[0]->nextNode(); $_[0]; },
  '--' => sub { $_[0]->previousNode(); $_[0]; },
  '<>' => sub { return wantarray ? $_[0]->_get_all() : $_[0]->nextNode(); },
;


sub new {
    my $class = shift;
    my $node  = shift;

    return undef unless defined $node;

    my $self = bless {}, $class;

    $self->{FIRST} = $node;
    # $self->first;

    $self->{CURRENT} = undef;
    $self->{INDEX} = -1;

    $self->{ITERATOR} = \&default_iterator;

    $self->{FILTERS} = [];

    return $self;
}


sub iterator_function {
    my $self = shift;
    my $func = shift;

    return if defined $func and ref( $func ) ne "CODE";

    $self->first;
    if ( defined $func ) {
        $self->{ITERATOR} = $func;
    }
    else {
        $self->{ITERATOR} = \&default_iterator;
    }
}

sub set_filter {
    my $self = shift;
    $self->{FILTERS} = [ @_ ];
}

sub add_filter {
    my $self = shift;
    push @{$self->{FILTERS}}, @_;
}

sub current  { return $_[0]->{CURRENT}; }
sub index    { return $_[0]->{INDEX}; }

sub next { return $_[0]->nextNode(); }
sub previous { return $_[0]->previousNode(); }

sub nextNode     {
    my $self = shift;
    my @filters = @{$self->{FILTERS}};
    my $node = undef;

    if ( $self->{INDEX} != -1 ) {
        my $fv = FILTER_SKIP;
        unless ( scalar @filters > 0 ) {
            $fv = FILTER_DECLINED;
        }

        while ( 1 ) {
            $node = $self->{ITERATOR}->( $self, 1 );
            last unless defined $node;
            foreach my $f ( @filters ) {
                $fv = $f->accept_node( $node );
                last if $fv;
            }
            last if $fv == FILTER_ACCEPT or $fv == FILTER_DECLINED;
        }
    }
    else {
        $node = $self->first();
    }

    if ( defined $node ) {
        $self->{CURRENT} = $node;
        if ( $node->isSameNode( $self->{FIRST} ) ) {
            $self->{INDEX} = 0;
        }
        else {
            $self->{INDEX}++;
        }
    }

    return $node;
}

sub previousNode {
    my $self = shift;
    my @filters = @{$self->{FILTERS}};
    my $node = undef;
    my $fv = FILTER_SKIP;
    unless ( scalar @filters > 0 ) {
        $fv = FILTER_DECLINED;
    }
    while ( 1 ) {
        $node = $self->{ITERATOR}->( $self, -1 );
        last unless defined $node;
        foreach my $f ( @filters ) {
            $fv = $f->accept_node( $node );
            last if $fv;
        }
        last if $fv == FILTER_ACCEPT or $fv == FILTER_DECLINED;
    }

    if ( defined $node ) {
        $self->{CURRENT} = $node;
        $self->{INDEX}--;
    }

    return $node;
}

sub first {
    my $self = shift;
    if ( scalar @_ ) {
        $self->{FIRST} = shift;
    }

    $self->{CURRENT} = $self->{FIRST};

    # this logic is required if the node is not allowed to be shown
    my @filters = @{$self->{FILTERS}||[]};
    my $fv = FILTER_DECLINED;

    foreach my $f ( @filters ) {
        $fv = $f->accept_node( $self->{CURRENT} );
        last if $fv;
    }

    $fv ||= FILTER_ACCEPT;

    unless ( $fv == FILTER_ACCEPT ) {
        return undef;
    }

    $self->{INDEX}   = 0;
    return $self->current;
}

sub last  {
    my $self = shift;
    while ($self->next) {}
    return $self->current;
}

sub iterate {
    my $self = shift;
    my $function = shift;
    return unless defined $function and ref( $function ) eq 'CODE' ;
    my $rv;
    my $node = $self->first;
    while ( $node ) {
        $rv = $function->($self,$node);
        $node = $self->next;
    }
    return $rv;
}

sub default_iterator {
    my $self = shift;
    my $dir  = shift;
    my $node = undef;


    if ( $dir < 0 ) {
        return undef if $self->{CURRENT}->isSameNode( $self->{FIRST} )
          and $self->{INDEX} <= 0;

        $node = $self->{CURRENT}->previousSibling;
        return $self->{CURRENT}->parentNode unless defined $node;

        while ( $node->hasChildNodes ) {
            $node = $node->lastChild;
        }
    }
    else {
        if ( defined $self->{CURRENT} ) {
            return undef if $self->{CURRENT}->isSameNode( $self->{FIRST} )
                and $self->{INDEX} > 0;

            if ( $self->{CURRENT}->hasChildNodes ) {
                $node = $self->{CURRENT}->firstChild;
            }
            else {
                $node = $self->{CURRENT}->nextSibling;
                my $pnode = $self->{CURRENT}->parentNode;
                while ( not defined $node ) {
                    last unless defined $pnode;
                    $node = $pnode->nextSibling;
                    $pnode = $pnode->parentNode unless defined $node;
                }
            }
        }
        else {
            $self->{CURRENT} = $self->{FIRST};
            $node = $self->{CURRENT};
        }
    }

    return $node;
}

# helper function for the <> operator
# returns all nodes that have not yet been accessed
sub _get_all {
    my $self = shift;
    my @retval = ();
    my $node;
    while ( $node = $self->next() ) {
        push @retval, $node;
    }
    return @retval;
}

1;
__END__