File Coverage

blib/lib/DateTime/Event/Cron/Quartz/TreeSet.pm

Criterion	Covered	Total	%
statement	61	65	93.8
branch	20	26	76.9
condition			n/a
subroutine	11	12	91.6
pod	7	8	87.5
total	99	111	89.1

package DateTime::Event::Cron::Quartz::TreeSet;

use 5.006001;
use strict;
use warnings;

our $VERSION = '0.05';

sub new {
    my $class = shift;

    my $list = shift;

    my $self = {
        _sorted => 0,
        _array  => defined $list ? $list : [],
        _index  => {}
    };

    return bless $self, $class;
}

sub size {
    return ( int @{ shift->{_array} } );
}

sub contains {
    my $self = shift;

    my $value = shift;

    return ( exists $self->{_index}->{$value} );
}

sub first_item {
    my $self = shift;

    if ( !$self->{_sorted} ) {
        $self->_sort;
    }

    return ( $self->size > 0 ? $self->{_array}->[0] : undef );
}

sub last_item {
    my $self = shift;
    if ( !$self->{_sorted} ) {
        $self->_sort;
    }

    return ( $self->size > 0 ? $self->{_array}->[ $self->size - 1 ] : undef );
}

sub add {
    my $self  = shift;
    my $value = shift;

    if ( !$self->contains($value) ) {
        push @{ $self->{_array} }, $value;
        $self->{_index}->{$value} = undef;
        $self->{_sorted} = 0;
    }

    return;
}

sub to_array {
    my $self = shift;

    if (!$self->{_sorted}) {
        $self->_sort;
    }

    return $self->{_array};
}

sub tail_set {
    my $self         = shift;
    my $from_element = shift;

    if ( !$self->{_sorted} ) {
        $self->_sort;
    }

    my $idx;

    if ( $self->contains($from_element) ) {

        # try to find in index
        $idx = $self->{_index}->{$from_element};
    }
    else {

        # find closest in array
        foreach my $val ( @{ $self->{_array} } ) {
            if ( $val >= $from_element ) {
                $idx = int $self->{_index}->{$val};
                CORE::last;
            }
        }
    }

    my $result_set;

    if ( defined $idx ) {
        my $size = $self->size - 1;

        $result_set = [ @{ $self->{_array} }[ $idx .. $size ] ];
    }

    return ( defined $result_set ? ( ref $self )->new($result_set) : undef );
}

# performs internal sorting and search index building
sub _sort {
    my $self = shift;

    if ( ( my $size = $self->size ) > 0 ) {
        $self->{_array} = [ CORE::sort { $a <=> $b } @{ $self->{_array} } ];

        # build search index
        foreach my $i ( 0 .. ( $size - 1 ) ) {
            $self->{_index}->{ $self->{_array}->[$i] } = $i;
        }
    }

    $self->{_sorted} = 1;

    return;
}

1;

__END__