File Coverage

blib/lib/XML/LibXML/Iterator.pm

Criterion	Covered	Total	%
statement	105	141	74.4
branch	34	58	58.6
condition	8	20	40.0
subroutine	14	23	60.8
pod	14	14	100.0
total	175	256	68.3

#
#
package XML::LibXML::Iterator;
$XML::LibXML::Iterator::VERSION = '1.06';
use strict;
use warnings;

use XML::NodeFilter qw(:results);

use vars qw($VERSION);

$VERSION = '1.04';

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

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 undef() 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 undef() 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__