File Coverage

blib/lib/DateTime/Span.pm

Criterion	Covered	Total	%
statement	114	143	79.7
branch	41	76	53.9
condition	7	12	58.3
subroutine	21	27	77.7
pod	16	19	84.2
total	199	277	71.8

# Copyright (c) 2003 Flavio Soibelmann Glock. All rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.

package DateTime::Span;

use strict;

use DateTime::Set;
use DateTime::SpanSet;

use Params::Validate qw( validate SCALAR BOOLEAN OBJECT CODEREF ARRAYREF );
use vars qw( $VERSION );

use constant INFINITY     => DateTime::INFINITY;
use constant NEG_INFINITY => DateTime::NEG_INFINITY;
$VERSION = $DateTime::Set::VERSION;

sub set_time_zone {
    my ( $self, $tz ) = @_;

    $self->{set} = $self->{set}->iterate(
        sub {
            my %tmp = %{ $_[0]->{list}[0] };
            $tmp{a} = $tmp{a}->clone->set_time_zone( $tz ) if ref $tmp{a};
            $tmp{b} = $tmp{b}->clone->set_time_zone( $tz ) if ref $tmp{b};
            \%tmp;
        }
    );
    return $self;
}

# note: the constructor must clone its DateTime parameters, such that
# the set elements become immutable
sub from_datetimes {
    my $class = shift;
    my %args = validate( @_,
                         { start =>
                           { type => OBJECT,
                             optional => 1,
                           },
                           end =>
                           { type => OBJECT,
                             optional => 1,
                           },
                           after =>
                           { type => OBJECT,
                             optional => 1,
                           },
                           before =>
                           { type => OBJECT,
                             optional => 1,
                           },
                         }
                       );
    my $self = {};
    my $set;

    die "No arguments given to DateTime::Span->from_datetimes\n"
        unless keys %args;

    if ( exists $args{start} && exists $args{after} ) {
        die "Cannot give both start and after arguments to DateTime::Span->from_datetimes\n";
    }
    if ( exists $args{end} && exists $args{before} ) {
        die "Cannot give both end and before arguments to DateTime::Span->from_datetimes\n";
    }

    my ( $start, $open_start, $end, $open_end );
    ( $start, $open_start ) = ( NEG_INFINITY,  0 );
    ( $start, $open_start ) = ( $args{start},  0 ) if exists $args{start};
    ( $start, $open_start ) = ( $args{after},  1 ) if exists $args{after};
    ( $end,   $open_end   ) = ( INFINITY,      0 );
    ( $end,   $open_end   ) = ( $args{end},    0 ) if exists $args{end};
    ( $end,   $open_end   ) = ( $args{before}, 1 ) if exists $args{before};

    if ( $start > $end ) {
        die "Span cannot start after the end in DateTime::Span->from_datetimes\n";
    }
    $set = Set::Infinite::_recurrence->new( $start, $end );
    if ( $start != $end ) {
        # remove start, such that we have ">" instead of ">="
        $set = $set->complement( $start ) if $open_start;
        # remove end, such that we have "<" instead of "<="
        $set = $set->complement( $end )   if $open_end;
    }

    $self->{set} = $set;
    bless $self, $class;
    return $self;
}

sub from_datetime_and_duration {
    my $class = shift;
    my %args = @_;

    my $key;
    my $dt;
    # extract datetime parameters
    for ( qw( start end before after ) ) {
        if ( exists $args{$_} ) {
           $key = $_;
           $dt = delete $args{$_};
       }
    }

    # extract duration parameters
    my $dt_duration;
    if ( exists $args{duration} ) {
        $dt_duration = $args{duration};
    }
    else {
        $dt_duration = DateTime::Duration->new( %args );
    }
    # warn "Creating span from $key => ".$dt->datetime." and $dt_duration";
    my $other_date;
    my $other_key;
    if ( $dt_duration->is_positive ) {
        if ( $key eq 'end' || $key eq 'before' ) {
            $other_key = 'start';
            $other_date = $dt->clone->subtract_duration( $dt_duration );
        }
        else {
            $other_key = 'before';
            $other_date = $dt->clone->add_duration( $dt_duration );
        }
    }
    else {
        if ( $key eq 'end' || $key eq 'before' ) {
            $other_key = 'start';
            $other_date = $dt->clone->add_duration( $dt_duration );
        }
        else {
            $other_key = 'before';
            $other_date = $dt->clone->subtract_duration( $dt_duration );
        }
    }
    # warn "Creating span from $key => ".$dt->datetime." and ".$other_date->datetime;
    return $class->new( $key => $dt, $other_key => $other_date );
}

# This method is intentionally not documented.  It's really only for
# use by ::Set and ::SpanSet's as_list() and iterator() methods.
sub new {
    my $class = shift;
    my %args = @_;

    # If we find anything _not_ appropriate for from_datetimes, we
    # assume it must be for durations, and call this constructor.
    # This way, we don't need to hardcode the DateTime::Duration
    # parameters.
    foreach ( keys %args )
    {
        return $class->from_datetime_and_duration(%args)
            unless /^(?:before|after|start|end)$/;
    }

    return $class->from_datetimes(%args);
}

sub is_empty_set {
    my $set = $_[0];
    $set->{set}->is_null;
}

sub clone {
    bless {
        set => $_[0]->{set}->copy,
        }, ref $_[0];
}

# Set::Infinite methods

sub intersection {
    my ($set1, $set2) = @_;
    my $class = ref($set1);
    my $tmp = {};  # $class->new();
    $set2 = $set2->as_spanset
        if $set2->can( 'as_spanset' );
    $set2 = $set2->as_set
        if $set2->can( 'as_set' );
    $set2 = DateTime::Set->from_datetimes( dates => [ $set2 ] )
        unless $set2->can( 'union' );
    $tmp->{set} = $set1->{set}->intersection( $set2->{set} );

    # intersection() can generate something more complex than a span.
    bless $tmp, 'DateTime::SpanSet';

    return $tmp;
}

sub intersects {
    my ($set1, $set2) = @_;
    my $class = ref($set1);
    $set2 = $set2->as_spanset
        if $set2->can( 'as_spanset' );
    $set2 = $set2->as_set
        if $set2->can( 'as_set' );
    $set2 = DateTime::Set->from_datetimes( dates => [ $set2 ] )
        unless $set2->can( 'union' );
    return $set1->{set}->intersects( $set2->{set} );
}

sub contains {
    my ($set1, $set2) = @_;
    my $class = ref($set1);
    $set2 = $set2->as_spanset
        if $set2->can( 'as_spanset' );
    $set2 = $set2->as_set
        if $set2->can( 'as_set' );
    $set2 = DateTime::Set->from_datetimes( dates => [ $set2 ] )
        unless $set2->can( 'union' );
    return $set1->{set}->contains( $set2->{set} );
}

sub union {
    my ($set1, $set2) = @_;
    my $class = ref($set1);
    my $tmp = {};   # $class->new();
    $set2 = $set2->as_spanset
        if $set2->can( 'as_spanset' );
    $set2 = $set2->as_set
        if $set2->can( 'as_set' );
    $set2 = DateTime::Set->from_datetimes( dates => [ $set2 ] )
        unless $set2->can( 'union' );
    $tmp->{set} = $set1->{set}->union( $set2->{set} );

    # union() can generate something more complex than a span.
    bless $tmp, 'DateTime::SpanSet';

    # # We have to check it's internal structure to find out.
    # if ( $#{ $tmp->{set}->{list} } != 0 ) {
    #    bless $tmp, 'Date::SpanSet';
    # }

    return $tmp;
}

sub complement {
    my ($set1, $set2) = @_;
    my $class = ref($set1);
    my $tmp = {};   # $class->new;
    if (defined $set2) {
        $set2 = $set2->as_spanset
            if $set2->can( 'as_spanset' );
        $set2 = $set2->as_set
            if $set2->can( 'as_set' );
        $set2 = DateTime::Set->from_datetimes( dates => [ $set2 ] )
            unless $set2->can( 'union' );
        $tmp->{set} = $set1->{set}->complement( $set2->{set} );
    }
    else {
        $tmp->{set} = $set1->{set}->complement;
    }

    # complement() can generate something more complex than a span.
    bless $tmp, 'DateTime::SpanSet';

    # # We have to check it's internal structure to find out.
    # if ( $#{ $tmp->{set}->{list} } != 0 ) {
    #    bless $tmp, 'Date::SpanSet';
    # }

    return $tmp;
}

sub start {
    return DateTime::Set::_fix_datetime( $_[0]->{set}->min );
}

*min = \&start;

sub end {
    return DateTime::Set::_fix_datetime( $_[0]->{set}->max );
}

*max = \&end;

sub start_is_open {
    # min_a returns info about the set boundary
    my ($min, $open) = $_[0]->{set}->min_a;
    return $open;
}

sub start_is_closed { $_[0]->start_is_open ? 0 : 1 }

sub end_is_open {
    # max_a returns info about the set boundary
    my ($max, $open) = $_[0]->{set}->max_a;
    return $open;
}

sub end_is_closed { $_[0]->end_is_open ? 0 : 1 }


# span == $self
sub span { @_ }

sub duration {
    my $dur;

    local $@;
    eval {
        local $SIG{__DIE__};   # don't want to trap this (rt ticket 5434)
        $dur = $_[0]->end->subtract_datetime_absolute( $_[0]->start )
    };

    return $dur if defined $dur;

    return DateTime::Infinite::Future->new -
           DateTime::Infinite::Past->new;
}
*size = \&duration;

1;

__END__