File Coverage

lib/XML/XMetaL/Utilities/Iterator.pm

Criterion	Covered	Total	%
statement	18	70	25.7
branch	0	30	0.0
condition	0	12	0.0
subroutine	6	17	35.2
pod	2	3	66.6
total	26	132	19.7

package XML::XMetaL::Utilities::Iterator;

use strict;
use warnings;

use Carp;
use Hash::Util qw(lock_keys);

use constant TRUE  => 1;
use constant FALSE => 0;

sub new {
    my ($class, %args) = @_;
    my $self;
    eval {
        lock_keys(%args, qw(-domnode -filter));
        die "-domnode argument is missing or not a DOM node type"
            unless $args{-domnode}->{nodeType};
        die "-filter argument is missing, or is not a subclass of XML::XMetaL::Utilities::Filter::Base"
            unless $args{-filter}->isa('XML::XMetaL::Utilities::Filter::Base');
        $self = bless {
            _next_node => $args{-domnode} || croak("-domnode parameter missing or undefined"),
            _filter    => $args{-filter},
            _depth     => 0,
        }, ref($class) || $class;
        lock_keys(%$self, keys %$self);
        my $next_node = $self->_get_next_node();
        my $filter = $self->_get_filter();
        unless ($filter->accept($next_node)) {
            $next_node = $self->_find_next_node($next_node);
            $self->_set_next_node($next_node);
        }
    };
    croak $@ if $@;
    return $self;
}

sub _get_next_node {$_[0]->{_next_node}}
sub _set_next_node {$_[0]->{_next_node} = $_[1];}

sub _get_filter {$_[0]->{_filter}}

sub _increment_depth {
    $_[0]->{_depth}++;
    #print "depth: ".$_[0]->_get_depth()."\n";
}
sub _decrement_depth {
    $_[0]->{_depth}--;
    #print "depth: ".$_[0]->_get_depth()."\n";
}

sub _get_depth {$_[0]->{_depth}}

sub has_next {
    my ($self) = @_;
    return $self->_get_next_node() ? TRUE : FALSE;
}

sub next {
    my ($self) = @_;
    my $current_node = $self->_get_next_node();
    my $next_node = $self->_find_next_node($current_node);
    $self->_set_next_node($next_node);
    return $current_node;
}

sub _find_next_node {
    my ($self, $current_node) = @_;
    return undef unless $current_node;
    my $child_nodes;
    my $next_node;
    my $filter = $self->_get_filter();

    if ($current_node->hasChildNodes()) {
        $self->_increment_depth();
        $child_nodes = $current_node->{childNodes};
        $next_node = $child_nodes->item(0);
        return $next_node if $filter->accept($next_node);
    } elsif ($self->_get_depth() >= 1 && $current_node->{nextSibling}) {
        $next_node = $current_node->{nextSibling};
        return $next_node if $filter->accept($next_node);
    #} elsif ($self->_get_depth() > 1 && $current_node->{parentNode}->{nextSibling}) {
    #    $self->_decrement_depth();
    #    $next_node = $current_node->{parentNode}->{nextSibling};
    #    return $next_node if $filter->accept($next_node);
    } elsif ($self->_get_depth() > 1 && $current_node->{parentNode}) {
        $next_node = $self->_traverse_tree_upwards_recursively($current_node);
        return $next_node if $filter->accept($next_node);
    }

    if ($next_node) {
        return $self->_find_next_node($next_node);
    }
    return undef;
}

#sub _traverse_tree_downwards {}
#
#sub _traverse_tree_sideways {}

sub _traverse_tree_upwards_recursively {
    my ($self, $current_node) = @_;
    return undef if $self->_get_depth() < 1;
    my $parent_node = $current_node->{parentNode};
    my $sibling_of_parent = $parent_node->{nextSibling};

    $self->_decrement_depth();
    if ($sibling_of_parent) {
        return $sibling_of_parent;
    } else {
        return $self->_traverse_tree_upwards_recursively($parent_node);
    }
}

1;

__END__