File Coverage

blib/lib/Tree/Simple/Visitor/FindByUID.pm

Criterion	Covered	Total	%
statement	57	57	100.0
branch	26	26	100.0
condition	13	15	86.6
subroutine	12	12	100.0
pod	5	5	100.0
total	113	115	98.2

package Tree::Simple::Visitor::FindByUID;

use strict;
use warnings;

our $VERSION = '0.15';

use Scalar::Util qw(blessed);

use base qw(Tree::Simple::Visitor);

sub new {
    my ($_class) = @_;
    my $class = ref($_class) || $_class;
    my $visitor = {};
    bless($visitor, $class);
    $visitor->_init();
    return $visitor;
}

sub _init {
    my ($self) = @_;
    $self->{success} = 0;
    $self->{UID_to_find} = undef;
    $self->SUPER::_init();
}

sub searchForUID {
    my ($self, $UID) = @_;
    (defined($UID)) || die "Insufficient Arguments : You must provide a UID to search for";
    $self->{UID_to_find} = $UID;
}

sub setTraversalMethod {
	my ($self, $visitor) = @_;
	(blessed($visitor) && $visitor->isa("Tree::Simple::Visitor"))
		|| die "Insufficient Arguments : You must supply a valid Tree::Simple::Visitor object";
    $self->{traversal_method} = $visitor;
}

sub visit {
	my ($self, $tree) = @_;
	(blessed($tree) && $tree->isa("Tree::Simple"))
		|| die "Insufficient Arguments : You must supply a valid Tree::Simple object";

    # reset our success flag
    $self->{success} = 0;

    my $UID = $self->{UID_to_find};
    (defined($UID)) || die "Illegal Operation : You cannot search for a UID without setting one first";
    # create our filter function
    # NOTE:
    # in order to get an immediate exit
    # from the traversal once a match is
    # found, we use 'die'. It is a somewhat
    # unorthodox way of using this, but it
    # works. The found tree is propagated
    # up the call chain and returned from
    # this function.
	my $func;
    if ($self->{_filter_function}) {
        $func = sub {
            my ($tree, $test) = @_;
            (($tree->getUID() eq $UID) &&  $self->{_filter_function}->($tree)) && die $tree;
            };
    }
    else {
        $func = sub {
            my ($tree, $test) = @_;
            ($tree->getUID() eq $UID) && die $tree;
            };
    }

    # we eval this so we can catch the tree
    # match when it is thrown with 'die'
    eval {
        unless (defined($self->{traversal_method})) {
            # include the trunk in our
            # search if needed
            $func->($tree) if $self->includeTrunk();
            # and traverse
            $tree->traverse($func);
        }
        else {
            # include the trunk in our
            # search if needed
            $self->{traversal_method}->includeTrunk(1) if $self->includeTrunk();
            # and visit
            $self->{traversal_method}->setNodeFilter($func);
            $self->{traversal_method}->visit($tree);
        }
    };
    # now see what we have ...
    if ($@) {
        # if we caught a Tree::Simple object
        # then we have found a match, and ...
        if (blessed($@) && $@->isa('Tree::Simple')) {
            # we assign it to our results
            $self->setResults($@);
            $self->{success} = 1;
        }
        # however, if it is not a Tree::Simple
        # object then it is likely a real exception
        else {
            # so we re-throw it
            die $@;
        }
    }
    else {
        # if no exception is thrown though,
        # we failed in our search, and so we
        # set our success flag to false
        $self->{success} = 0;
    }
}

sub getResult {
    my ($self) = @_;
    # if we did not succeed, then
    # we return undef, ...
    return undef unless $self->{success};
    # otherwise we return the results
    return $self->getResults()->[0];
}

1;

__END__