view release on metacpan or  search on metacpan

lib/DateTimeX/Moment/Duration.pm  view on Meta::CPAN

sub delta_months      { shift->{months}      }
sub delta_days        { shift->{days}        }
sub delta_minutes     { shift->{minutes}     }
sub delta_seconds     { shift->{seconds}     }
sub delta_nanoseconds { shift->{nanoseconds} }

sub in_units {
    my $self  = shift;
    my @units = @_;

    my %units = map { $_ => 1 } @units;

    my %ret;

    my ($months, $days, $minutes, $seconds) = @$self{qw/months days minutes seconds/};
    if ($units{years}) {
        $ret{years} = int($months / 12);
        $months -= $ret{years} * 12;
    }

    if ($units{months}) {
        $ret{months} = $months;
    }

    if ($units{weeks}) {
        $ret{weeks} = int($days / 7);
        $days -= $ret{weeks} * 7;
    }

    if ($units{days}) {
        $ret{days} = $days;
    }

    if ($units{hours}) {
        $ret{hours} = int($minutes / 60);
        $minutes -= $ret{hours} * 60;
    }

    if ($units{minutes}) {
        $ret{minutes} = $minutes;
    }

    if ($units{seconds}) {
        $ret{seconds} = $seconds;
        $seconds = 0;
    }

    if ($units{nanoseconds}) {
        $ret{nanoseconds} = $seconds * 1_000_000_000 + $self->{nanoseconds};
    }

    return wantarray ? @ret{@units} : $ret{$units[0]};
}

# XXX: limit mode only
sub is_wrap_mode      { 0 }
sub is_limit_mode     { 1 }
sub is_preserve_mode  { 0 }
sub end_of_month_mode { 'limit' }

sub calendar_duration {
    my $self = shift;
    my $clone = $self->clone;
    $clone->{$_} = 0 for qw/minutes seconds nanoseconds/;
    return $clone;
}

sub clock_duration {
    my $self = shift;
    my $clone = $self->clone;
    $clone->{$_} = 0 for qw/months days/;
    return $clone;
}

sub inverse {
    my $self = shift;
    my $clone = $self->clone;
    $clone->{$_} *= -1 for keys %$clone;
    return $clone;
}

sub add_duration {
    my ($lhs, $rhs) = @_;
    $lhs->{$_} += $rhs->{$_} for ALL_UNITS;
    return $lhs->_normalize_nanoseconds();
}

sub add {
    my $self = shift;
    my $class = ref $self;

    my $lhs = $self;
    my $rhs = $class->new(@_);
    return $lhs->add_duration($rhs);
}

sub subtract_duration { $_[0]->add_duration($_[1]->inverse) }

sub subtract {
    my $self = shift;
    my $class = ref $self;

    my $lhs = $self;
    my $rhs = $class->new(@_);
    return $lhs->subtract_duration($rhs);
}

sub multiply {
    my ($lhs, $rhs) = @_;
    $lhs->{$_} *= $rhs for ALL_UNITS;
    return $lhs->_normalize_nanoseconds();
}

sub compare {
    my ($class, $lhs, $rhs, $base) = @_;
    $base ||= DateTimeX::Moment->now;
    return DateTimeX::Moment->compare(
        $base->clone->add_duration($lhs),
        $base->clone->add_duration($rhs)
    );
}