line |
stmt |
bran |
cond |
sub |
pod |
time |
code |
1
|
|
|
|
|
|
|
package DateTime::Duration; |
2
|
|
|
|
|
|
|
|
3
|
49
|
|
|
49
|
|
830
|
use strict; |
|
49
|
|
|
|
|
108
|
|
|
49
|
|
|
|
|
1487
|
|
4
|
49
|
|
|
49
|
|
267
|
use warnings; |
|
49
|
|
|
|
|
106
|
|
|
49
|
|
|
|
|
1203
|
|
5
|
49
|
|
|
49
|
|
254
|
use namespace::autoclean; |
|
49
|
|
|
|
|
105
|
|
|
49
|
|
|
|
|
280
|
|
6
|
|
|
|
|
|
|
|
7
|
|
|
|
|
|
|
our $VERSION = '1.62'; |
8
|
|
|
|
|
|
|
|
9
|
49
|
|
|
49
|
|
3655
|
use Carp (); |
|
49
|
|
|
|
|
126
|
|
|
49
|
|
|
|
|
1257
|
|
10
|
49
|
|
|
49
|
|
307
|
use DateTime; |
|
49
|
|
|
|
|
105
|
|
|
49
|
|
|
|
|
1625
|
|
11
|
49
|
|
|
49
|
|
19910
|
use DateTime::Helpers; |
|
49
|
|
|
|
|
140
|
|
|
49
|
|
|
|
|
1443
|
|
12
|
49
|
|
|
49
|
|
19100
|
use DateTime::Types; |
|
49
|
|
|
|
|
249
|
|
|
49
|
|
|
|
|
686
|
|
13
|
49
|
|
|
49
|
|
1631275
|
use Params::ValidationCompiler 0.26 qw( validation_for ); |
|
49
|
|
|
|
|
909207
|
|
|
49
|
|
|
|
|
3169
|
|
14
|
49
|
|
|
49
|
|
415
|
use Scalar::Util qw( blessed ); |
|
49
|
|
|
|
|
152
|
|
|
49
|
|
|
|
|
2871
|
|
15
|
|
|
|
|
|
|
|
16
|
|
|
|
|
|
|
use overload ( |
17
|
49
|
|
|
|
|
342
|
fallback => 1, |
18
|
|
|
|
|
|
|
'+' => '_add_overload', |
19
|
|
|
|
|
|
|
'-' => '_subtract_overload', |
20
|
|
|
|
|
|
|
'*' => '_multiply_overload', |
21
|
|
|
|
|
|
|
'<=>' => '_compare_overload', |
22
|
|
|
|
|
|
|
'cmp' => '_compare_overload', |
23
|
49
|
|
|
49
|
|
381
|
); |
|
49
|
|
|
|
|
145
|
|
24
|
|
|
|
|
|
|
|
25
|
|
|
|
|
|
|
sub MAX_NANOSECONDS () {1_000_000_000} # 1E9 = almost 32 bits |
26
|
|
|
|
|
|
|
|
27
|
|
|
|
|
|
|
my @all_units = qw( months days minutes seconds nanoseconds ); |
28
|
|
|
|
|
|
|
|
29
|
|
|
|
|
|
|
{ |
30
|
|
|
|
|
|
|
my %units = map { |
31
|
|
|
|
|
|
|
$_ => { |
32
|
|
|
|
|
|
|
|
33
|
|
|
|
|
|
|
# XXX - what we really want is to accept an integer, Inf, -Inf, |
34
|
|
|
|
|
|
|
# and NaN, but I can't figure out how to accept NaN since it never |
35
|
|
|
|
|
|
|
# compares to anything. |
36
|
|
|
|
|
|
|
type => t('Defined'), |
37
|
|
|
|
|
|
|
default => 0, |
38
|
|
|
|
|
|
|
} |
39
|
|
|
|
|
|
|
} qw( |
40
|
|
|
|
|
|
|
years |
41
|
|
|
|
|
|
|
months |
42
|
|
|
|
|
|
|
weeks |
43
|
|
|
|
|
|
|
days |
44
|
|
|
|
|
|
|
hours |
45
|
|
|
|
|
|
|
minutes |
46
|
|
|
|
|
|
|
seconds |
47
|
|
|
|
|
|
|
nanoseconds |
48
|
|
|
|
|
|
|
); |
49
|
|
|
|
|
|
|
|
50
|
|
|
|
|
|
|
my $check = validation_for( |
51
|
|
|
|
|
|
|
name => '_check_new_params', |
52
|
|
|
|
|
|
|
name_is_optional => 1, |
53
|
|
|
|
|
|
|
params => { |
54
|
|
|
|
|
|
|
%units, |
55
|
|
|
|
|
|
|
end_of_month => { |
56
|
|
|
|
|
|
|
type => t('EndOfMonthMode'), |
57
|
|
|
|
|
|
|
optional => 1, |
58
|
|
|
|
|
|
|
}, |
59
|
|
|
|
|
|
|
}, |
60
|
|
|
|
|
|
|
); |
61
|
|
|
|
|
|
|
|
62
|
|
|
|
|
|
|
sub new { |
63
|
32024
|
|
|
32024
|
1
|
372776
|
my $class = shift; |
64
|
32024
|
|
|
|
|
675363
|
my %p = $check->(@_); |
65
|
|
|
|
|
|
|
|
66
|
32024
|
|
|
|
|
1691462
|
my $self = bless {}, $class; |
67
|
|
|
|
|
|
|
|
68
|
32024
|
|
|
|
|
68261
|
$self->{months} = ( $p{years} * 12 ) + $p{months}; |
69
|
|
|
|
|
|
|
|
70
|
32024
|
|
|
|
|
47850
|
$self->{days} = ( $p{weeks} * 7 ) + $p{days}; |
71
|
|
|
|
|
|
|
|
72
|
32024
|
|
|
|
|
49617
|
$self->{minutes} = ( $p{hours} * 60 ) + $p{minutes}; |
73
|
|
|
|
|
|
|
|
74
|
32024
|
|
|
|
|
47364
|
$self->{seconds} = $p{seconds}; |
75
|
|
|
|
|
|
|
|
76
|
32024
|
100
|
|
|
|
55165
|
if ( $p{nanoseconds} ) { |
77
|
39
|
|
|
|
|
76
|
$self->{nanoseconds} = $p{nanoseconds}; |
78
|
39
|
|
|
|
|
104
|
$self->_normalize_nanoseconds; |
79
|
|
|
|
|
|
|
} |
80
|
|
|
|
|
|
|
else { |
81
|
|
|
|
|
|
|
|
82
|
|
|
|
|
|
|
# shortcut - if they don't need nanoseconds |
83
|
31985
|
|
|
|
|
47303
|
$self->{nanoseconds} = 0; |
84
|
|
|
|
|
|
|
} |
85
|
|
|
|
|
|
|
|
86
|
|
|
|
|
|
|
$self->{end_of_month} = ( |
87
|
|
|
|
|
|
|
defined $p{end_of_month} ? $p{end_of_month} |
88
|
32024
|
100
|
|
|
|
81449
|
: $self->{months} < 0 ? 'preserve' |
|
|
100
|
|
|
|
|
|
89
|
|
|
|
|
|
|
: 'wrap' |
90
|
|
|
|
|
|
|
); |
91
|
|
|
|
|
|
|
|
92
|
32024
|
|
|
|
|
139928
|
return $self; |
93
|
|
|
|
|
|
|
} |
94
|
|
|
|
|
|
|
} |
95
|
|
|
|
|
|
|
|
96
|
|
|
|
|
|
|
# make the signs of seconds, nanos the same; 0 < abs(nanos) < MAX_NANOS |
97
|
|
|
|
|
|
|
# NB this requires nanoseconds != 0 (callers check this already) |
98
|
|
|
|
|
|
|
sub _normalize_nanoseconds { |
99
|
48
|
|
|
48
|
|
85
|
my $self = shift; |
100
|
|
|
|
|
|
|
|
101
|
|
|
|
|
|
|
return |
102
|
|
|
|
|
|
|
if ( $self->{nanoseconds} == DateTime::INFINITY() |
103
|
|
|
|
|
|
|
|| $self->{nanoseconds} == DateTime::NEG_INFINITY() |
104
|
48
|
100
|
100
|
|
|
449
|
|| $self->{nanoseconds} eq DateTime::NAN() ); |
|
|
|
100
|
|
|
|
|
105
|
|
|
|
|
|
|
|
106
|
45
|
|
|
|
|
134
|
my $seconds = $self->{seconds} + $self->{nanoseconds} / MAX_NANOSECONDS; |
107
|
45
|
|
|
|
|
91
|
$self->{seconds} = int($seconds); |
108
|
45
|
|
|
|
|
83
|
$self->{nanoseconds} = $self->{nanoseconds} % MAX_NANOSECONDS; |
109
|
45
|
100
|
|
|
|
113
|
$self->{nanoseconds} -= MAX_NANOSECONDS if $seconds < 0; |
110
|
|
|
|
|
|
|
} |
111
|
|
|
|
|
|
|
|
112
|
12
|
|
|
12
|
1
|
30
|
sub clone { bless { %{ $_[0] } }, ref $_[0] } |
|
12
|
|
|
|
|
95
|
|
113
|
|
|
|
|
|
|
|
114
|
4
|
|
|
4
|
1
|
656
|
sub years { abs( $_[0]->in_units('years') ) } |
115
|
4
|
|
|
4
|
1
|
36
|
sub months { abs( $_[0]->in_units( 'months', 'years' ) ) } |
116
|
4
|
|
|
4
|
1
|
647
|
sub weeks { abs( $_[0]->in_units('weeks') ) } |
117
|
4
|
|
|
4
|
1
|
635
|
sub days { abs( $_[0]->in_units( 'days', 'weeks' ) ) } |
118
|
10
|
|
|
10
|
1
|
657
|
sub hours { abs( $_[0]->in_units('hours') ) } |
119
|
7
|
|
|
7
|
1
|
707
|
sub minutes { abs( $_[0]->in_units( 'minutes', 'hours' ) ) } |
120
|
7
|
|
|
7
|
1
|
1068
|
sub seconds { abs( $_[0]->in_units('seconds') ) } |
121
|
4
|
|
|
4
|
1
|
674
|
sub nanoseconds { abs( $_[0]->in_units( 'nanoseconds', 'seconds' ) ) } |
122
|
|
|
|
|
|
|
|
123
|
8
|
100
|
|
8
|
1
|
5191
|
sub is_positive { $_[0]->_has_positive && !$_[0]->_has_negative } |
124
|
10
|
100
|
|
10
|
1
|
41
|
sub is_negative { !$_[0]->_has_positive && $_[0]->_has_negative } |
125
|
|
|
|
|
|
|
|
126
|
|
|
|
|
|
|
sub _has_positive { |
127
|
18
|
100
|
|
18
|
|
40
|
( grep { $_ > 0 } @{ $_[0] }{@all_units} ) ? 1 : 0; |
|
90
|
|
|
|
|
298
|
|
|
18
|
|
|
|
|
73
|
|
128
|
|
|
|
|
|
|
} |
129
|
|
|
|
|
|
|
|
130
|
|
|
|
|
|
|
sub _has_negative { |
131
|
13
|
100
|
|
13
|
|
27
|
( grep { $_ < 0 } @{ $_[0] }{@all_units} ) ? 1 : 0; |
|
65
|
|
|
|
|
184
|
|
|
13
|
|
|
|
|
33
|
|
132
|
|
|
|
|
|
|
} |
133
|
|
|
|
|
|
|
|
134
|
|
|
|
|
|
|
sub is_zero { |
135
|
32690
|
100
|
|
32690
|
1
|
48085
|
return 0 if grep { $_ != 0 } @{ $_[0] }{@all_units}; |
|
163450
|
|
|
|
|
306635
|
|
|
32690
|
|
|
|
|
93334
|
|
136
|
747
|
|
|
|
|
4069
|
return 1; |
137
|
|
|
|
|
|
|
} |
138
|
|
|
|
|
|
|
|
139
|
30
|
|
|
30
|
1
|
852
|
sub delta_months { $_[0]->{months} } |
140
|
36
|
|
|
36
|
1
|
260
|
sub delta_days { $_[0]->{days} } |
141
|
29
|
|
|
29
|
1
|
231
|
sub delta_minutes { $_[0]->{minutes} } |
142
|
47
|
|
|
47
|
1
|
351
|
sub delta_seconds { $_[0]->{seconds} } |
143
|
33
|
|
|
33
|
1
|
190
|
sub delta_nanoseconds { $_[0]->{nanoseconds} } |
144
|
|
|
|
|
|
|
|
145
|
|
|
|
|
|
|
sub deltas { |
146
|
63897
|
|
|
63897
|
1
|
90050
|
map { $_ => $_[0]->{$_} } @all_units; |
|
319485
|
|
|
|
|
615357
|
|
147
|
|
|
|
|
|
|
} |
148
|
|
|
|
|
|
|
|
149
|
|
|
|
|
|
|
sub in_units { |
150
|
64
|
|
|
64
|
1
|
143
|
my $self = shift; |
151
|
64
|
|
|
|
|
149
|
my @units = @_; |
152
|
|
|
|
|
|
|
|
153
|
64
|
|
|
|
|
131
|
my %units = map { $_ => 1 } @units; |
|
95
|
|
|
|
|
279
|
|
154
|
|
|
|
|
|
|
|
155
|
64
|
|
|
|
|
109
|
my %ret; |
156
|
|
|
|
|
|
|
|
157
|
|
|
|
|
|
|
my ( $months, $days, $minutes, $seconds ) |
158
|
64
|
|
|
|
|
117
|
= @{$self}{qw( months days minutes seconds )}; |
|
64
|
|
|
|
|
169
|
|
159
|
|
|
|
|
|
|
|
160
|
64
|
100
|
|
|
|
171
|
if ( $units{years} ) { |
161
|
12
|
|
|
|
|
39
|
$ret{years} = int( $months / 12 ); |
162
|
12
|
|
|
|
|
26
|
$months -= $ret{years} * 12; |
163
|
|
|
|
|
|
|
} |
164
|
|
|
|
|
|
|
|
165
|
64
|
100
|
|
|
|
130
|
if ( $units{months} ) { |
166
|
8
|
|
|
|
|
14
|
$ret{months} = $months; |
167
|
|
|
|
|
|
|
} |
168
|
|
|
|
|
|
|
|
169
|
64
|
100
|
|
|
|
130
|
if ( $units{weeks} ) { |
170
|
11
|
|
|
|
|
34
|
$ret{weeks} = int( $days / 7 ); |
171
|
11
|
|
|
|
|
21
|
$days -= $ret{weeks} * 7; |
172
|
|
|
|
|
|
|
} |
173
|
|
|
|
|
|
|
|
174
|
64
|
100
|
|
|
|
127
|
if ( $units{days} ) { |
175
|
8
|
|
|
|
|
18
|
$ret{days} = $days; |
176
|
|
|
|
|
|
|
} |
177
|
|
|
|
|
|
|
|
178
|
64
|
100
|
|
|
|
161
|
if ( $units{hours} ) { |
179
|
21
|
|
|
|
|
55
|
$ret{hours} = int( $minutes / 60 ); |
180
|
21
|
|
|
|
|
40
|
$minutes -= $ret{hours} * 60; |
181
|
|
|
|
|
|
|
} |
182
|
|
|
|
|
|
|
|
183
|
64
|
100
|
|
|
|
137
|
if ( $units{minutes} ) { |
184
|
11
|
|
|
|
|
29
|
$ret{minutes} = $minutes; |
185
|
|
|
|
|
|
|
} |
186
|
|
|
|
|
|
|
|
187
|
64
|
100
|
|
|
|
127
|
if ( $units{seconds} ) { |
188
|
16
|
|
|
|
|
66
|
$ret{seconds} = $seconds; |
189
|
16
|
|
|
|
|
27
|
$seconds = 0; |
190
|
|
|
|
|
|
|
} |
191
|
|
|
|
|
|
|
|
192
|
64
|
100
|
|
|
|
119
|
if ( $units{nanoseconds} ) { |
193
|
8
|
|
|
|
|
24
|
$ret{nanoseconds} = $seconds * MAX_NANOSECONDS + $self->{nanoseconds}; |
194
|
|
|
|
|
|
|
} |
195
|
|
|
|
|
|
|
|
196
|
64
|
100
|
|
|
|
504
|
wantarray ? @ret{@units} : $ret{ $units[0] }; |
197
|
|
|
|
|
|
|
} |
198
|
|
|
|
|
|
|
|
199
|
541
|
100
|
|
541
|
1
|
2096
|
sub is_wrap_mode { $_[0]->{end_of_month} eq 'wrap' ? 1 : 0 } |
200
|
3
|
50
|
|
3
|
1
|
25
|
sub is_limit_mode { $_[0]->{end_of_month} eq 'limit' ? 1 : 0 } |
201
|
1081
|
100
|
|
1081
|
1
|
4308
|
sub is_preserve_mode { $_[0]->{end_of_month} eq 'preserve' ? 1 : 0 } |
202
|
|
|
|
|
|
|
|
203
|
2
|
|
|
2
|
1
|
20
|
sub end_of_month_mode { $_[0]->{end_of_month} } |
204
|
|
|
|
|
|
|
|
205
|
|
|
|
|
|
|
sub calendar_duration { |
206
|
3
|
|
|
3
|
1
|
41
|
my $self = shift; |
207
|
|
|
|
|
|
|
|
208
|
|
|
|
|
|
|
return ( ref $self ) |
209
|
3
|
|
|
|
|
10
|
->new( map { $_ => $self->{$_} } qw( months days end_of_month ) ); |
|
9
|
|
|
|
|
28
|
|
210
|
|
|
|
|
|
|
} |
211
|
|
|
|
|
|
|
|
212
|
|
|
|
|
|
|
sub clock_duration { |
213
|
3
|
|
|
3
|
1
|
9
|
my $self = shift; |
214
|
|
|
|
|
|
|
|
215
|
|
|
|
|
|
|
return ( ref $self ) |
216
|
3
|
|
|
|
|
13
|
->new( map { $_ => $self->{$_} } |
|
12
|
|
|
|
|
38
|
|
217
|
|
|
|
|
|
|
qw( minutes seconds nanoseconds end_of_month ) ); |
218
|
|
|
|
|
|
|
} |
219
|
|
|
|
|
|
|
|
220
|
|
|
|
|
|
|
sub inverse { |
221
|
22890
|
|
|
22890
|
1
|
31658
|
my $self = shift; |
222
|
22890
|
|
|
|
|
34437
|
my %p = @_; |
223
|
|
|
|
|
|
|
|
224
|
22890
|
|
|
|
|
25980
|
my %new; |
225
|
22890
|
|
|
|
|
37995
|
foreach my $u (@all_units) { |
226
|
114450
|
|
|
|
|
174971
|
$new{$u} = $self->{$u}; |
227
|
|
|
|
|
|
|
|
228
|
|
|
|
|
|
|
# avoid -0 bug |
229
|
114450
|
100
|
|
|
|
195464
|
$new{$u} *= -1 if $new{$u}; |
230
|
|
|
|
|
|
|
} |
231
|
|
|
|
|
|
|
|
232
|
|
|
|
|
|
|
$new{end_of_month} = $p{end_of_month} |
233
|
22890
|
100
|
|
|
|
40829
|
if exists $p{end_of_month}; |
234
|
|
|
|
|
|
|
|
235
|
22890
|
|
|
|
|
67991
|
return ( ref $self )->new(%new); |
236
|
|
|
|
|
|
|
} |
237
|
|
|
|
|
|
|
|
238
|
|
|
|
|
|
|
sub add_duration { |
239
|
17
|
|
|
17
|
1
|
63
|
my ( $self, $dur ) = @_; |
240
|
|
|
|
|
|
|
|
241
|
17
|
|
|
|
|
43
|
foreach my $u (@all_units) { |
242
|
85
|
|
|
|
|
151
|
$self->{$u} += $dur->{$u}; |
243
|
|
|
|
|
|
|
} |
244
|
|
|
|
|
|
|
|
245
|
17
|
100
|
|
|
|
48
|
$self->_normalize_nanoseconds if $self->{nanoseconds}; |
246
|
|
|
|
|
|
|
|
247
|
17
|
|
|
|
|
76
|
return $self; |
248
|
|
|
|
|
|
|
} |
249
|
|
|
|
|
|
|
|
250
|
|
|
|
|
|
|
sub add { |
251
|
5
|
|
|
5
|
1
|
24
|
my $self = shift; |
252
|
|
|
|
|
|
|
|
253
|
5
|
|
|
|
|
15
|
return $self->add_duration( $self->_duration_object_from_args(@_) ); |
254
|
|
|
|
|
|
|
} |
255
|
|
|
|
|
|
|
|
256
|
|
|
|
|
|
|
sub subtract { |
257
|
5
|
|
|
5
|
1
|
10
|
my $self = shift; |
258
|
|
|
|
|
|
|
|
259
|
5
|
|
|
|
|
12
|
return $self->subtract_duration( $self->_duration_object_from_args(@_) ); |
260
|
|
|
|
|
|
|
} |
261
|
|
|
|
|
|
|
|
262
|
|
|
|
|
|
|
# Syntactic sugar for add and subtract: use a duration object if it's |
263
|
|
|
|
|
|
|
# supplied, otherwise build a new one from the arguments. |
264
|
|
|
|
|
|
|
sub _duration_object_from_args { |
265
|
10
|
|
|
10
|
|
16
|
my $self = shift; |
266
|
|
|
|
|
|
|
|
267
|
10
|
50
|
66
|
|
|
51
|
return $_[0] |
|
|
|
66
|
|
|
|
|
268
|
|
|
|
|
|
|
if @_ == 1 && blessed( $_[0] ) && $_[0]->isa(__PACKAGE__); |
269
|
|
|
|
|
|
|
|
270
|
8
|
|
|
|
|
20
|
return __PACKAGE__->new(@_); |
271
|
|
|
|
|
|
|
} |
272
|
|
|
|
|
|
|
|
273
|
11
|
|
|
11
|
1
|
26
|
sub subtract_duration { return $_[0]->add_duration( $_[1]->inverse ) } |
274
|
|
|
|
|
|
|
|
275
|
|
|
|
|
|
|
{ |
276
|
|
|
|
|
|
|
my $check = validation_for( |
277
|
|
|
|
|
|
|
name => '_check_multiply_params', |
278
|
|
|
|
|
|
|
name_is_optional => 1, |
279
|
|
|
|
|
|
|
params => [ |
280
|
|
|
|
|
|
|
{ type => t('Int') }, |
281
|
|
|
|
|
|
|
], |
282
|
|
|
|
|
|
|
); |
283
|
|
|
|
|
|
|
|
284
|
|
|
|
|
|
|
sub multiply { |
285
|
4
|
|
|
4
|
1
|
8
|
my $self = shift; |
286
|
4
|
|
|
|
|
95
|
my ($multiplier) = $check->(@_); |
287
|
|
|
|
|
|
|
|
288
|
3
|
|
|
|
|
61
|
foreach my $u (@all_units) { |
289
|
15
|
|
|
|
|
27
|
$self->{$u} *= $multiplier; |
290
|
|
|
|
|
|
|
} |
291
|
|
|
|
|
|
|
|
292
|
3
|
100
|
|
|
|
15
|
$self->_normalize_nanoseconds if $self->{nanoseconds}; |
293
|
|
|
|
|
|
|
|
294
|
3
|
|
|
|
|
16
|
return $self; |
295
|
|
|
|
|
|
|
} |
296
|
|
|
|
|
|
|
} |
297
|
|
|
|
|
|
|
|
298
|
|
|
|
|
|
|
sub compare { |
299
|
5
|
|
|
5
|
1
|
683
|
my ( undef, $dur1, $dur2, $dt ) = @_; |
300
|
|
|
|
|
|
|
|
301
|
5
|
|
66
|
|
|
24
|
$dt ||= DateTime->now; |
302
|
|
|
|
|
|
|
|
303
|
5
|
|
|
|
|
15
|
return DateTime->compare( |
304
|
|
|
|
|
|
|
$dt->clone->add_duration($dur1), |
305
|
|
|
|
|
|
|
$dt->clone->add_duration($dur2) |
306
|
|
|
|
|
|
|
); |
307
|
|
|
|
|
|
|
} |
308
|
|
|
|
|
|
|
|
309
|
|
|
|
|
|
|
sub _add_overload { |
310
|
1
|
|
|
1
|
|
14
|
my ( $d1, $d2, $rev ) = @_; |
311
|
|
|
|
|
|
|
|
312
|
1
|
50
|
|
|
|
4
|
( $d1, $d2 ) = ( $d2, $d1 ) if $rev; |
313
|
|
|
|
|
|
|
|
314
|
1
|
50
|
|
|
|
5
|
if ( DateTime::Helpers::isa( $d2, 'DateTime' ) ) { |
315
|
0
|
|
|
|
|
0
|
$d2->add_duration($d1); |
316
|
0
|
|
|
|
|
0
|
return; |
317
|
|
|
|
|
|
|
} |
318
|
|
|
|
|
|
|
|
319
|
|
|
|
|
|
|
# will also work if $d1 is a DateTime.pm object |
320
|
1
|
|
|
|
|
13
|
return $d1->clone->add_duration($d2); |
321
|
|
|
|
|
|
|
} |
322
|
|
|
|
|
|
|
|
323
|
|
|
|
|
|
|
sub _subtract_overload { |
324
|
6
|
|
|
6
|
|
18
|
my ( $d1, $d2, $rev ) = @_; |
325
|
|
|
|
|
|
|
|
326
|
6
|
50
|
|
|
|
19
|
( $d1, $d2 ) = ( $d2, $d1 ) if $rev; |
327
|
|
|
|
|
|
|
|
328
|
6
|
50
|
|
|
|
14
|
Carp::croak( |
329
|
|
|
|
|
|
|
'Cannot subtract a DateTime object from a DateTime::Duration object') |
330
|
|
|
|
|
|
|
if DateTime::Helpers::isa( $d2, 'DateTime' ); |
331
|
|
|
|
|
|
|
|
332
|
6
|
|
|
|
|
18
|
return $d1->clone->subtract_duration($d2); |
333
|
|
|
|
|
|
|
} |
334
|
|
|
|
|
|
|
|
335
|
|
|
|
|
|
|
sub _multiply_overload { |
336
|
3
|
|
|
3
|
|
107
|
my $self = shift; |
337
|
|
|
|
|
|
|
|
338
|
3
|
|
|
|
|
8
|
my $new = $self->clone; |
339
|
|
|
|
|
|
|
|
340
|
3
|
|
|
|
|
21
|
return $new->multiply(shift); |
341
|
|
|
|
|
|
|
} |
342
|
|
|
|
|
|
|
|
343
|
|
|
|
|
|
|
sub _compare_overload { |
344
|
1
|
|
|
1
|
|
267
|
Carp::croak( 'DateTime::Duration does not overload comparison.' |
345
|
|
|
|
|
|
|
. ' See the documentation on the compare() method for details.' |
346
|
|
|
|
|
|
|
); |
347
|
|
|
|
|
|
|
} |
348
|
|
|
|
|
|
|
|
349
|
|
|
|
|
|
|
1; |
350
|
|
|
|
|
|
|
|
351
|
|
|
|
|
|
|
# ABSTRACT: Duration objects for date math |
352
|
|
|
|
|
|
|
|
353
|
|
|
|
|
|
|
__END__ |
354
|
|
|
|
|
|
|
|
355
|
|
|
|
|
|
|
=pod |
356
|
|
|
|
|
|
|
|
357
|
|
|
|
|
|
|
=encoding UTF-8 |
358
|
|
|
|
|
|
|
|
359
|
|
|
|
|
|
|
=head1 NAME |
360
|
|
|
|
|
|
|
|
361
|
|
|
|
|
|
|
DateTime::Duration - Duration objects for date math |
362
|
|
|
|
|
|
|
|
363
|
|
|
|
|
|
|
=head1 VERSION |
364
|
|
|
|
|
|
|
|
365
|
|
|
|
|
|
|
version 1.62 |
366
|
|
|
|
|
|
|
|
367
|
|
|
|
|
|
|
=head1 SYNOPSIS |
368
|
|
|
|
|
|
|
|
369
|
|
|
|
|
|
|
use DateTime::Duration; |
370
|
|
|
|
|
|
|
|
371
|
|
|
|
|
|
|
$dur = DateTime::Duration->new( |
372
|
|
|
|
|
|
|
years => 3, |
373
|
|
|
|
|
|
|
months => 5, |
374
|
|
|
|
|
|
|
weeks => 1, |
375
|
|
|
|
|
|
|
days => 1, |
376
|
|
|
|
|
|
|
hours => 6, |
377
|
|
|
|
|
|
|
minutes => 15, |
378
|
|
|
|
|
|
|
seconds => 45, |
379
|
|
|
|
|
|
|
nanoseconds => 12000, |
380
|
|
|
|
|
|
|
end_of_month => 'limit', |
381
|
|
|
|
|
|
|
); |
382
|
|
|
|
|
|
|
|
383
|
|
|
|
|
|
|
my ( $days, $hours, $seconds ) |
384
|
|
|
|
|
|
|
= $dur->in_units( 'days', 'hours', 'seconds' ); |
385
|
|
|
|
|
|
|
|
386
|
|
|
|
|
|
|
# Human-readable accessors, always positive, but consider using |
387
|
|
|
|
|
|
|
# DateTime::Format::Duration instead |
388
|
|
|
|
|
|
|
$dur->years; |
389
|
|
|
|
|
|
|
$dur->months; |
390
|
|
|
|
|
|
|
$dur->weeks; |
391
|
|
|
|
|
|
|
$dur->days; |
392
|
|
|
|
|
|
|
$dur->hours; |
393
|
|
|
|
|
|
|
$dur->minutes; |
394
|
|
|
|
|
|
|
$dur->seconds; |
395
|
|
|
|
|
|
|
$dur->nanoseconds; |
396
|
|
|
|
|
|
|
|
397
|
|
|
|
|
|
|
$dur->is_wrap_mode; |
398
|
|
|
|
|
|
|
$dur->is_limit_mode; |
399
|
|
|
|
|
|
|
$dur->is_preserve_mode; |
400
|
|
|
|
|
|
|
|
401
|
|
|
|
|
|
|
print $dur->end_of_month_mode; |
402
|
|
|
|
|
|
|
|
403
|
|
|
|
|
|
|
# Multiply all values by -1 |
404
|
|
|
|
|
|
|
my $opposite = $dur->inverse; |
405
|
|
|
|
|
|
|
|
406
|
|
|
|
|
|
|
my $bigger = $dur1 + $dur2; |
407
|
|
|
|
|
|
|
my $smaller = $dur1 - $dur2; # the result could be negative |
408
|
|
|
|
|
|
|
my $bigger = $dur1 * 3; |
409
|
|
|
|
|
|
|
|
410
|
|
|
|
|
|
|
my $base_dt = DateTime->new( year => 2000 ); |
411
|
|
|
|
|
|
|
my @sorted |
412
|
|
|
|
|
|
|
= sort { DateTime::Duration->compare( $a, $b, $base_dt ) } @durations; |
413
|
|
|
|
|
|
|
|
414
|
|
|
|
|
|
|
if ( $dur->is_positive ) {...} |
415
|
|
|
|
|
|
|
if ( $dur->is_zero ) {...} |
416
|
|
|
|
|
|
|
if ( $dur->is_negative ) {...} |
417
|
|
|
|
|
|
|
|
418
|
|
|
|
|
|
|
=head1 DESCRIPTION |
419
|
|
|
|
|
|
|
|
420
|
|
|
|
|
|
|
This is a simple class for representing duration objects. These objects are |
421
|
|
|
|
|
|
|
used whenever you do date math with L<DateTime>. |
422
|
|
|
|
|
|
|
|
423
|
|
|
|
|
|
|
See the L<How DateTime Math Works|DateTime/"How DateTime Math Works"> section |
424
|
|
|
|
|
|
|
of the L<DateTime> documentation for more details. The short course: One cannot |
425
|
|
|
|
|
|
|
in general convert between seconds, minutes, days, and months, so this class |
426
|
|
|
|
|
|
|
will never do so. Instead, create the duration with the desired units to begin |
427
|
|
|
|
|
|
|
with, for example by calling the appropriate subtraction/delta method on a |
428
|
|
|
|
|
|
|
L<DateTime> object. |
429
|
|
|
|
|
|
|
|
430
|
|
|
|
|
|
|
=head1 METHODS |
431
|
|
|
|
|
|
|
|
432
|
|
|
|
|
|
|
Like L<DateTime> itself, C<DateTime::Duration> returns the object from mutator |
433
|
|
|
|
|
|
|
methods in order to make method chaining possible. |
434
|
|
|
|
|
|
|
|
435
|
|
|
|
|
|
|
C<DateTime::Duration> has the following methods: |
436
|
|
|
|
|
|
|
|
437
|
|
|
|
|
|
|
=head2 DateTime::Duration->new( ... ) |
438
|
|
|
|
|
|
|
|
439
|
|
|
|
|
|
|
This class method accepts the following parameters: |
440
|
|
|
|
|
|
|
|
441
|
|
|
|
|
|
|
=over 4 |
442
|
|
|
|
|
|
|
|
443
|
|
|
|
|
|
|
=item * years |
444
|
|
|
|
|
|
|
|
445
|
|
|
|
|
|
|
An integer containing the number of years in the duration. This is optional. |
446
|
|
|
|
|
|
|
|
447
|
|
|
|
|
|
|
=item * months |
448
|
|
|
|
|
|
|
|
449
|
|
|
|
|
|
|
An integer containing the number of months in the duration. This is optional. |
450
|
|
|
|
|
|
|
|
451
|
|
|
|
|
|
|
=item * weeks |
452
|
|
|
|
|
|
|
|
453
|
|
|
|
|
|
|
An integer containing the number of weeks in the duration. This is optional. |
454
|
|
|
|
|
|
|
|
455
|
|
|
|
|
|
|
=item * days |
456
|
|
|
|
|
|
|
|
457
|
|
|
|
|
|
|
An integer containing the number of days in the duration. This is optional. |
458
|
|
|
|
|
|
|
|
459
|
|
|
|
|
|
|
=item * hours |
460
|
|
|
|
|
|
|
|
461
|
|
|
|
|
|
|
An integer containing the number of hours in the duration. This is optional. |
462
|
|
|
|
|
|
|
|
463
|
|
|
|
|
|
|
=item * minutes |
464
|
|
|
|
|
|
|
|
465
|
|
|
|
|
|
|
An integer containing the number of minutes in the duration. This is optional. |
466
|
|
|
|
|
|
|
|
467
|
|
|
|
|
|
|
=item * seconds |
468
|
|
|
|
|
|
|
|
469
|
|
|
|
|
|
|
An integer containing the number of seconds in the duration. This is optional. |
470
|
|
|
|
|
|
|
|
471
|
|
|
|
|
|
|
=item * nanoseconds |
472
|
|
|
|
|
|
|
|
473
|
|
|
|
|
|
|
An integer containing the number of nanoseconds in the duration. This is |
474
|
|
|
|
|
|
|
optional. |
475
|
|
|
|
|
|
|
|
476
|
|
|
|
|
|
|
=item * end_of_month |
477
|
|
|
|
|
|
|
|
478
|
|
|
|
|
|
|
This must be either C<"wrap">, C<"limit">, or C<"preserve">. This parameter |
479
|
|
|
|
|
|
|
specifies how date math that crosses the end of a month is handled. |
480
|
|
|
|
|
|
|
|
481
|
|
|
|
|
|
|
In C<"wrap"> mode, adding months or years that result in days beyond the end of |
482
|
|
|
|
|
|
|
the new month will roll over into the following month. For instance, adding one |
483
|
|
|
|
|
|
|
year to Feb 29 will result in Mar 1. |
484
|
|
|
|
|
|
|
|
485
|
|
|
|
|
|
|
If you specify C<"limit">, the end of the month is never crossed. Thus, adding |
486
|
|
|
|
|
|
|
one year to Feb 29, 2000 will result in Feb 28, 2001. If you were to then add |
487
|
|
|
|
|
|
|
three more years this will result in Feb 28, 2004. |
488
|
|
|
|
|
|
|
|
489
|
|
|
|
|
|
|
If you specify C<"preserve">, the same calculation is done as for C<"limit"> |
490
|
|
|
|
|
|
|
except that if the original date is at the end of the month the new date will |
491
|
|
|
|
|
|
|
also be. For instance, adding one month to Feb 29, 2000 will result in Mar 31, |
492
|
|
|
|
|
|
|
2000. |
493
|
|
|
|
|
|
|
|
494
|
|
|
|
|
|
|
For positive durations, this parameter defaults to C<"wrap">. For negative |
495
|
|
|
|
|
|
|
durations, the default is C<"preserve">. This should match how most people |
496
|
|
|
|
|
|
|
"intuitively" expect datetime math to work. |
497
|
|
|
|
|
|
|
|
498
|
|
|
|
|
|
|
=back |
499
|
|
|
|
|
|
|
|
500
|
|
|
|
|
|
|
All of the duration units can be positive or negative. However, if any of the |
501
|
|
|
|
|
|
|
numbers are negative, the entire duration is negative. |
502
|
|
|
|
|
|
|
|
503
|
|
|
|
|
|
|
All of the numbers B<must be integers>. |
504
|
|
|
|
|
|
|
|
505
|
|
|
|
|
|
|
Internally, years as just treated as 12 months. Similarly, weeks are treated as |
506
|
|
|
|
|
|
|
7 days, and hours are converted to minutes. Seconds and nanoseconds are both |
507
|
|
|
|
|
|
|
treated separately. |
508
|
|
|
|
|
|
|
|
509
|
|
|
|
|
|
|
=head2 $dur->clone |
510
|
|
|
|
|
|
|
|
511
|
|
|
|
|
|
|
Returns a new object with the same properties as the object on which this |
512
|
|
|
|
|
|
|
method was called. |
513
|
|
|
|
|
|
|
|
514
|
|
|
|
|
|
|
=head2 $dur->in_units( ... ) |
515
|
|
|
|
|
|
|
|
516
|
|
|
|
|
|
|
Returns the length of the duration in the units (any of those that can be |
517
|
|
|
|
|
|
|
passed to C<< DateTime::Duration->new >>) given as arguments. All lengths are |
518
|
|
|
|
|
|
|
integral, but may be negative. Smaller units are computed from what remains |
519
|
|
|
|
|
|
|
after taking away the larger units given, so for example: |
520
|
|
|
|
|
|
|
|
521
|
|
|
|
|
|
|
my $dur = DateTime::Duration->new( years => 1, months => 15 ); |
522
|
|
|
|
|
|
|
|
523
|
|
|
|
|
|
|
$dur->in_units('years'); # 2 |
524
|
|
|
|
|
|
|
$dur->in_units('months'); # 27 |
525
|
|
|
|
|
|
|
$dur->in_units( 'years', 'months' ); # (2, 3) |
526
|
|
|
|
|
|
|
$dur->in_units( 'weeks', 'days' ); # (0, 0) ! |
527
|
|
|
|
|
|
|
|
528
|
|
|
|
|
|
|
The last example demonstrates that there will not be any conversion between |
529
|
|
|
|
|
|
|
units which don't have a fixed conversion rate. The only conversions possible |
530
|
|
|
|
|
|
|
are: |
531
|
|
|
|
|
|
|
|
532
|
|
|
|
|
|
|
=over 4 |
533
|
|
|
|
|
|
|
|
534
|
|
|
|
|
|
|
=item * years <=> months |
535
|
|
|
|
|
|
|
|
536
|
|
|
|
|
|
|
=item * weeks <=> days |
537
|
|
|
|
|
|
|
|
538
|
|
|
|
|
|
|
=item * hours <=> minutes |
539
|
|
|
|
|
|
|
|
540
|
|
|
|
|
|
|
=item * seconds <=> nanoseconds |
541
|
|
|
|
|
|
|
|
542
|
|
|
|
|
|
|
=back |
543
|
|
|
|
|
|
|
|
544
|
|
|
|
|
|
|
For the explanation of why this is the case, please see the L<How DateTime Math |
545
|
|
|
|
|
|
|
Works|DateTime/"How DateTime Math Works"> section of the DateTime documentation |
546
|
|
|
|
|
|
|
|
547
|
|
|
|
|
|
|
Note that the numbers returned by this method may not match the values given to |
548
|
|
|
|
|
|
|
the constructor. |
549
|
|
|
|
|
|
|
|
550
|
|
|
|
|
|
|
In list context, C<< $dur->in_units >> returns the lengths in the order of the |
551
|
|
|
|
|
|
|
units given. In scalar context, it returns the length in the first unit (but |
552
|
|
|
|
|
|
|
still computes in terms of all given units). |
553
|
|
|
|
|
|
|
|
554
|
|
|
|
|
|
|
If you need more flexibility in presenting information about durations, please |
555
|
|
|
|
|
|
|
take a look a L<DateTime::Format::Duration>. |
556
|
|
|
|
|
|
|
|
557
|
|
|
|
|
|
|
=head2 $dur->is_positive, $dur->is_zero, $dur->is_negative |
558
|
|
|
|
|
|
|
|
559
|
|
|
|
|
|
|
Indicates whether or not the duration is positive, zero, or negative. |
560
|
|
|
|
|
|
|
|
561
|
|
|
|
|
|
|
If the duration contains both positive and negative units, then it will return |
562
|
|
|
|
|
|
|
false for B<all> of these methods. |
563
|
|
|
|
|
|
|
|
564
|
|
|
|
|
|
|
=head2 $dur->is_wrap_mode, $dur->is_limit_mode, $dur->is_preserve_mode |
565
|
|
|
|
|
|
|
|
566
|
|
|
|
|
|
|
Indicates what mode is used for end of month wrapping. |
567
|
|
|
|
|
|
|
|
568
|
|
|
|
|
|
|
=head2 $dur->end_of_month_mode |
569
|
|
|
|
|
|
|
|
570
|
|
|
|
|
|
|
Returns one of C<"wrap">, C<"limit">, or C<"preserve">. |
571
|
|
|
|
|
|
|
|
572
|
|
|
|
|
|
|
=head2 $dur->calendar_duration |
573
|
|
|
|
|
|
|
|
574
|
|
|
|
|
|
|
Returns a new object with the same I<calendar> delta (months and days only) and |
575
|
|
|
|
|
|
|
end of month mode as the current object. |
576
|
|
|
|
|
|
|
|
577
|
|
|
|
|
|
|
=head2 $dur->clock_duration |
578
|
|
|
|
|
|
|
|
579
|
|
|
|
|
|
|
Returns a new object with the same I<clock> deltas (minutes, seconds, and |
580
|
|
|
|
|
|
|
nanoseconds) and end of month mode as the current object. |
581
|
|
|
|
|
|
|
|
582
|
|
|
|
|
|
|
=head2 $dur->inverse( ... ) |
583
|
|
|
|
|
|
|
|
584
|
|
|
|
|
|
|
Returns a new object with the same deltas as the current object, but multiplied |
585
|
|
|
|
|
|
|
by -1. The end of month mode for the new object will be the default end of |
586
|
|
|
|
|
|
|
month mode, which depends on whether the new duration is positive or negative. |
587
|
|
|
|
|
|
|
|
588
|
|
|
|
|
|
|
You can set the end of month mode in the inverted duration explicitly by |
589
|
|
|
|
|
|
|
passing an C<end_of_month> parameter to the C<< $dur->inverse >> method. |
590
|
|
|
|
|
|
|
|
591
|
|
|
|
|
|
|
=head2 $dur->add_duration($duration_object), $dur->subtract_duration($duration_object) |
592
|
|
|
|
|
|
|
|
593
|
|
|
|
|
|
|
Adds or subtracts one duration from another. |
594
|
|
|
|
|
|
|
|
595
|
|
|
|
|
|
|
=head2 $dur->add( ... ), $dur->subtract( ... ) |
596
|
|
|
|
|
|
|
|
597
|
|
|
|
|
|
|
These accept either constructor parameters for a new C<DateTime::Duration> |
598
|
|
|
|
|
|
|
object or an already-constructed duration object. |
599
|
|
|
|
|
|
|
|
600
|
|
|
|
|
|
|
=head2 $dur->multiply($number) |
601
|
|
|
|
|
|
|
|
602
|
|
|
|
|
|
|
Multiplies each unit in the C<DateTime::Duration> object by the specified |
603
|
|
|
|
|
|
|
integer number. |
604
|
|
|
|
|
|
|
|
605
|
|
|
|
|
|
|
=head2 DateTime::Duration->compare( $duration1, $duration2, $base_datetime ) |
606
|
|
|
|
|
|
|
|
607
|
|
|
|
|
|
|
This is a class method that can be used to compare or sort durations. |
608
|
|
|
|
|
|
|
Comparison is done by adding each duration to the specified L<DateTime> object |
609
|
|
|
|
|
|
|
and comparing the resulting datetimes. This is necessary because without a |
610
|
|
|
|
|
|
|
base, many durations are not comparable. For example, 1 month may or may not be |
611
|
|
|
|
|
|
|
longer than 29 days, depending on what datetime it is added to. |
612
|
|
|
|
|
|
|
|
613
|
|
|
|
|
|
|
If no base datetime is given, then the result of C<< DateTime->now >> is used |
614
|
|
|
|
|
|
|
instead. Using this default will give non-repeatable results if used to compare |
615
|
|
|
|
|
|
|
two duration objects containing different units. It will also give |
616
|
|
|
|
|
|
|
non-repeatable results if the durations contain multiple types of units, such |
617
|
|
|
|
|
|
|
as months and days. |
618
|
|
|
|
|
|
|
|
619
|
|
|
|
|
|
|
However, if you know that both objects only consist of one type of unit (months |
620
|
|
|
|
|
|
|
I<or> days I<or> hours, etc.), and each duration contains the same type of |
621
|
|
|
|
|
|
|
unit, then the results of the comparison will be repeatable. |
622
|
|
|
|
|
|
|
|
623
|
|
|
|
|
|
|
=head2 $dur->delta_months, $dur->delta_days, $dur->delta_minutes, $dur->delta_seconds, $dur->delta_nanoseconds |
624
|
|
|
|
|
|
|
|
625
|
|
|
|
|
|
|
These methods provide the information L<DateTime> needs for doing date math. |
626
|
|
|
|
|
|
|
The numbers returned may be positive or negative. This is mostly useful for |
627
|
|
|
|
|
|
|
doing date math in L<DateTime>. |
628
|
|
|
|
|
|
|
|
629
|
|
|
|
|
|
|
=head2 $dur->deltas |
630
|
|
|
|
|
|
|
|
631
|
|
|
|
|
|
|
Returns a hash with the keys "months", "days", "minutes", "seconds", and |
632
|
|
|
|
|
|
|
"nanoseconds", containing all the delta information for the object. This is |
633
|
|
|
|
|
|
|
mostly useful for doing date math in L<DateTime>. |
634
|
|
|
|
|
|
|
|
635
|
|
|
|
|
|
|
=head2 $dur->years, $dur->months, $dur->weeks, $dur->days, $dur->hours, $dur->minutes, $dur->seconds, $dur->nanoseconds |
636
|
|
|
|
|
|
|
|
637
|
|
|
|
|
|
|
These methods return numbers indicating how many of the given unit the object |
638
|
|
|
|
|
|
|
represents, after having done a conversion to any larger units. For example, |
639
|
|
|
|
|
|
|
days are first converted to weeks, and then the remainder is returned. These |
640
|
|
|
|
|
|
|
numbers are always positive. |
641
|
|
|
|
|
|
|
|
642
|
|
|
|
|
|
|
Here's what each method returns: |
643
|
|
|
|
|
|
|
|
644
|
|
|
|
|
|
|
$dur->years == abs( $dur->in_units('years') ) |
645
|
|
|
|
|
|
|
$dur->months == abs( ( $dur->in_units( 'months', 'years' ) )[0] ) |
646
|
|
|
|
|
|
|
$dur->weeks == abs( $dur->in_units( 'weeks' ) ) |
647
|
|
|
|
|
|
|
$dur->days == abs( ( $dur->in_units( 'days', 'weeks' ) )[0] ) |
648
|
|
|
|
|
|
|
$dur->hours == abs( $dur->in_units( 'hours' ) ) |
649
|
|
|
|
|
|
|
$dur->minutes == abs( ( $dur->in_units( 'minutes', 'hours' ) )[0] ) |
650
|
|
|
|
|
|
|
$dur->seconds == abs( $dur->in_units( 'seconds' ) ) |
651
|
|
|
|
|
|
|
$dur->nanoseconds == abs( ( $dur->in_units( 'nanoseconds', 'seconds' ) )[0] ) |
652
|
|
|
|
|
|
|
|
653
|
|
|
|
|
|
|
If this seems confusing, remember that you can always use the C<< |
654
|
|
|
|
|
|
|
$dur->in_units >> method to specify exactly what you want. |
655
|
|
|
|
|
|
|
|
656
|
|
|
|
|
|
|
Better yet, if you are trying to generate output suitable for humans, use the |
657
|
|
|
|
|
|
|
C<DateTime::Format::Duration> module. |
658
|
|
|
|
|
|
|
|
659
|
|
|
|
|
|
|
=head2 Overloading |
660
|
|
|
|
|
|
|
|
661
|
|
|
|
|
|
|
This class overloads addition, subtraction, and mutiplication. |
662
|
|
|
|
|
|
|
|
663
|
|
|
|
|
|
|
Comparison is B<not> overloaded. If you attempt to compare durations using C<< |
664
|
|
|
|
|
|
|
<=> >> or C<cmp>, then an exception will be thrown! Use the C<compare> class |
665
|
|
|
|
|
|
|
method instead. |
666
|
|
|
|
|
|
|
|
667
|
|
|
|
|
|
|
=head1 SEE ALSO |
668
|
|
|
|
|
|
|
|
669
|
|
|
|
|
|
|
datetime@perl.org mailing list |
670
|
|
|
|
|
|
|
|
671
|
|
|
|
|
|
|
=head1 SUPPORT |
672
|
|
|
|
|
|
|
|
673
|
|
|
|
|
|
|
Support for this module is provided via the datetime@perl.org email list. See |
674
|
|
|
|
|
|
|
http://lists.perl.org/ for more details. |
675
|
|
|
|
|
|
|
|
676
|
|
|
|
|
|
|
Bugs may be submitted at L<https://github.com/houseabsolute/DateTime.pm/issues>. |
677
|
|
|
|
|
|
|
|
678
|
|
|
|
|
|
|
There is a mailing list available for users of this distribution, |
679
|
|
|
|
|
|
|
L<mailto:datetime@perl.org>. |
680
|
|
|
|
|
|
|
|
681
|
|
|
|
|
|
|
=head1 SOURCE |
682
|
|
|
|
|
|
|
|
683
|
|
|
|
|
|
|
The source code repository for DateTime can be found at L<https://github.com/houseabsolute/DateTime.pm>. |
684
|
|
|
|
|
|
|
|
685
|
|
|
|
|
|
|
=head1 AUTHOR |
686
|
|
|
|
|
|
|
|
687
|
|
|
|
|
|
|
Dave Rolsky <autarch@urth.org> |
688
|
|
|
|
|
|
|
|
689
|
|
|
|
|
|
|
=head1 COPYRIGHT AND LICENSE |
690
|
|
|
|
|
|
|
|
691
|
|
|
|
|
|
|
This software is Copyright (c) 2003 - 2023 by Dave Rolsky. |
692
|
|
|
|
|
|
|
|
693
|
|
|
|
|
|
|
This is free software, licensed under: |
694
|
|
|
|
|
|
|
|
695
|
|
|
|
|
|
|
The Artistic License 2.0 (GPL Compatible) |
696
|
|
|
|
|
|
|
|
697
|
|
|
|
|
|
|
The full text of the license can be found in the |
698
|
|
|
|
|
|
|
F<LICENSE> file included with this distribution. |
699
|
|
|
|
|
|
|
|
700
|
|
|
|
|
|
|
=cut |