File Coverage

blib/lib/Tree/Simple/Visitor.pm

Criterion	Covered	Total	%
statement	59	59	100.0
branch	26	26	100.0
condition	17	20	85.0
subroutine	16	16	100.0
pod	8	8	100.0
total	126	129	97.6

package Tree::Simple::Visitor;

use strict;
use warnings;

our $VERSION = '1.34';

use Scalar::Util qw(blessed);

## class constants

use constant RECURSIVE     => 0x01;
use constant CHILDREN_ONLY => 0x10;

### constructor

sub new {
	my ($_class, $func, $depth) = @_;
	if (defined($depth)){
		($depth =~ /\d+/ && ($depth == RECURSIVE || $depth == CHILDREN_ONLY))
                    || die "Insufficient Arguments : Depth arguement must be either ".
                    "RECURSIVE or CHILDREN_ONLY";
	}
	my $class = ref($_class) || $_class;
    # if we have not supplied a $func
    # it is automatically RECURSIVE
    $depth = RECURSIVE unless defined $func;
	my $visitor = {
		depth => $depth || 0
		};
	bless($visitor, $class);
	$visitor->_init();
    if (defined $func) {
        $visitor->setNodeFilter($func);
        $visitor->includeTrunk(1);
    }
	return $visitor;
}

### methods

sub _init {
	my ($self) = @_;
    $self->{_include_trunk} = 0;
    $self->{_filter_function} = undef;
    $self->{_results} = [];
}

sub includeTrunk {
    my ($self, $boolean) = @_;
    $self->{_include_trunk} = ($boolean ? 1 : 0) if defined $boolean;
    return $self->{_include_trunk};
}

# node filter methods

sub getNodeFilter {
    my ($self) = @_;
	return $self->{_filter_function};
}

sub clearNodeFilter {
    my ($self) = @_;
	$self->{_filter_function} = undef;
}

sub setNodeFilter {
    my ($self, $filter_function) = @_;
	(defined($filter_function) && ref($filter_function) eq "CODE")
            || die "Insufficient Arguments : filter function argument must be a subroutine reference";
	$self->{_filter_function} = $filter_function;
}

# results methods

sub setResults {
    my ($self, @results) = @_;
    $self->{results} = \@results;
}

sub getResults {
    my ($self) = @_;
    return wantarray ?
             @{$self->{results}}
             :
             $self->{results};
}

# visit routine
sub visit {
	my ($self, $tree) = @_;
	(blessed($tree) && $tree->isa("Tree::Simple"))
            || die "Insufficient Arguments : You must supply a valid Tree::Simple object";
    # get all things set up
	my @results;
	my $func;
    if ($self->{_filter_function}) {
        $func = sub { push @results => $self->{_filter_function}->(@_) };
    }
    else {
        $func = sub { push @results => $_[0]->getNodeValue() };
    }
	# always apply the function
	# to the tree's node

    $func->($tree) if (defined($self->{_include_trunk}) && $self->{_include_trunk});

	# then recursively to all its children
	# if the object is configured that way
	$tree->traverse($func) if ($self->{depth} == RECURSIVE);
	# or just visit its immediate children
	# if the object is configured that way
	if ($self->{depth} == CHILDREN_ONLY) {
		$func->($_) foreach $tree->getAllChildren();
	}
    # now store the results we got
    $self->setResults(@results);
}


1;

__END__