-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathOffsetTime.java
More file actions
1416 lines (1348 loc) · 59 KB
/
OffsetTime.java
File metadata and controls
1416 lines (1348 loc) · 59 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
* Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of JSR-310 nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package java.time;
import static java.time.LocalTime.NANOS_PER_HOUR;
import static java.time.LocalTime.NANOS_PER_MINUTE;
import static java.time.LocalTime.NANOS_PER_SECOND;
import static java.time.LocalTime.SECONDS_PER_DAY;
import static java.time.temporal.ChronoField.NANO_OF_DAY;
import static java.time.temporal.ChronoField.OFFSET_SECONDS;
import static java.time.temporal.ChronoUnit.NANOS;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalQueries;
import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalUnit;
import java.time.temporal.UnsupportedTemporalTypeException;
import java.time.temporal.ValueRange;
import java.time.zone.ZoneRules;
import java.util.Objects;
/**
* A time with an offset from UTC/Greenwich in the ISO-8601 calendar system,
* such as {@code 10:15:30+01:00}.
* <p>
* {@code OffsetTime} is an immutable date-time object that represents a time, often
* viewed as hour-minute-second-offset.
* This class stores all time fields, to a precision of nanoseconds,
* as well as a zone offset.
* For example, the value "13:45.30.123456789+02:00" can be stored
* in an {@code OffsetTime}.
*
* <p>
* This is a <a href="{@docRoot}/java/lang/doc-files/ValueBased.html">value-based</a>
* class; use of identity-sensitive operations (including reference equality
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code OffsetTime} may have unpredictable results and should be avoided.
* The {@code equals} method should be used for comparisons.
*
* @implSpec
* This class is immutable and thread-safe.
*
* @since 1.8
*/
public final class OffsetTime
implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable {
/**
* The minimum supported {@code OffsetTime}, '00:00:00+18:00'.
* This is the time of midnight at the start of the day in the maximum offset
* (larger offsets are earlier on the time-line).
* This combines {@link LocalTime#MIN} and {@link ZoneOffset#MAX}.
* This could be used by an application as a "far past" date.
*/
public static final OffsetTime MIN = LocalTime.MIN.atOffset(ZoneOffset.MAX);
/**
* The maximum supported {@code OffsetTime}, '23:59:59.999999999-18:00'.
* This is the time just before midnight at the end of the day in the minimum offset
* (larger negative offsets are later on the time-line).
* This combines {@link LocalTime#MAX} and {@link ZoneOffset#MIN}.
* This could be used by an application as a "far future" date.
*/
public static final OffsetTime MAX = LocalTime.MAX.atOffset(ZoneOffset.MIN);
/**
* Serialization version.
*/
private static final long serialVersionUID = 7264499704384272492L;
/**
* The local date-time.
*/
private final LocalTime time;
/**
* The offset from UTC/Greenwich.
*/
private final ZoneOffset offset;
//-----------------------------------------------------------------------
/**
* Obtains the current time from the system clock in the default time-zone.
* <p>
* This will query the {@link java.time.Clock#systemDefaultZone() system clock} in the default
* time-zone to obtain the current time.
* The offset will be calculated from the time-zone in the clock.
* <p>
* Using this method will prevent the ability to use an alternate clock for testing
* because the clock is hard-coded.
*
* @return the current time using the system clock, not null
*/
public static OffsetTime now() {
return now(Clock.systemDefaultZone());
}
/**
* Obtains the current time from the system clock in the specified time-zone.
* <p>
* This will query the {@link Clock#system(java.time.ZoneId) system clock} to obtain the current time.
* Specifying the time-zone avoids dependence on the default time-zone.
* The offset will be calculated from the specified time-zone.
* <p>
* Using this method will prevent the ability to use an alternate clock for testing
* because the clock is hard-coded.
*
* @param zone the zone ID to use, not null
* @return the current time using the system clock, not null
*/
public static OffsetTime now(ZoneId zone) {
return now(Clock.system(zone));
}
/**
* Obtains the current time from the specified clock.
* <p>
* This will query the specified clock to obtain the current time.
* The offset will be calculated from the time-zone in the clock.
* <p>
* Using this method allows the use of an alternate clock for testing.
* The alternate clock may be introduced using {@link Clock dependency injection}.
*
* @param clock the clock to use, not null
* @return the current time, not null
*/
public static OffsetTime now(Clock clock) {
Objects.requireNonNull(clock, "clock");
final Instant now = clock.instant(); // called once
return ofInstant(now, clock.getZone().getRules().getOffset(now));
}
//-----------------------------------------------------------------------
/**
* Obtains an instance of {@code OffsetTime} from a local time and an offset.
*
* @param time the local time, not null
* @param offset the zone offset, not null
* @return the offset time, not null
*/
public static OffsetTime of(LocalTime time, ZoneOffset offset) {
return new OffsetTime(time, offset);
}
/**
* Obtains an instance of {@code OffsetTime} from an hour, minute, second and nanosecond.
* <p>
* This creates an offset time with the four specified fields.
* <p>
* This method exists primarily for writing test cases.
* Non test-code will typically use other methods to create an offset time.
* {@code LocalTime} has two additional convenience variants of the
* equivalent factory method taking fewer arguments.
* They are not provided here to reduce the footprint of the API.
*
* @param hour the hour-of-day to represent, from 0 to 23
* @param minute the minute-of-hour to represent, from 0 to 59
* @param second the second-of-minute to represent, from 0 to 59
* @param nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999
* @param offset the zone offset, not null
* @return the offset time, not null
* @throws DateTimeException if the value of any field is out of range
*/
public static OffsetTime of(int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset) {
return new OffsetTime(LocalTime.of(hour, minute, second, nanoOfSecond), offset);
}
//-----------------------------------------------------------------------
/**
* Obtains an instance of {@code OffsetTime} from an {@code Instant} and zone ID.
* <p>
* This creates an offset time with the same instant as that specified.
* Finding the offset from UTC/Greenwich is simple as there is only one valid
* offset for each instant.
* <p>
* The date component of the instant is dropped during the conversion.
* This means that the conversion can never fail due to the instant being
* out of the valid range of dates.
*
* @param instant the instant to create the time from, not null
* @param zone the time-zone, which may be an offset, not null
* @return the offset time, not null
*/
public static OffsetTime ofInstant(Instant instant, ZoneId zone) {
Objects.requireNonNull(instant, "instant");
Objects.requireNonNull(zone, "zone");
ZoneRules rules = zone.getRules();
ZoneOffset offset = rules.getOffset(instant);
long localSecond = instant.getEpochSecond() + offset.getTotalSeconds(); // overflow caught later
int secsOfDay = (int) Math.floorMod(localSecond, SECONDS_PER_DAY);
LocalTime time = LocalTime.ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + instant.getNano());
return new OffsetTime(time, offset);
}
//-----------------------------------------------------------------------
/**
* Obtains an instance of {@code OffsetTime} from a temporal object.
* <p>
* This obtains an offset time based on the specified temporal.
* A {@code TemporalAccessor} represents an arbitrary set of date and time information,
* which this factory converts to an instance of {@code OffsetTime}.
* <p>
* The conversion extracts and combines the {@code ZoneOffset} and the
* {@code LocalTime} from the temporal object.
* Implementations are permitted to perform optimizations such as accessing
* those fields that are equivalent to the relevant objects.
* <p>
* This method matches the signature of the functional interface {@link TemporalQuery}
* allowing it to be used in queries via method reference, {@code OffsetTime::from}.
*
* @param temporal the temporal object to convert, not null
* @return the offset time, not null
* @throws DateTimeException if unable to convert to an {@code OffsetTime}
*/
public static OffsetTime from(TemporalAccessor temporal) {
if (temporal instanceof OffsetTime) {
return (OffsetTime) temporal;
}
try {
LocalTime time = LocalTime.from(temporal);
ZoneOffset offset = ZoneOffset.from(temporal);
return new OffsetTime(time, offset);
} catch (DateTimeException ex) {
throw new DateTimeException("Unable to obtain OffsetTime from TemporalAccessor: " +
temporal + " of type " + temporal.getClass().getName(), ex);
}
}
//-----------------------------------------------------------------------
/**
* Obtains an instance of {@code OffsetTime} from a text string such as {@code 10:15:30+01:00}.
* <p>
* The string must represent a valid time and is parsed using
* {@link java.time.format.DateTimeFormatter#ISO_OFFSET_TIME}.
*
* @param text the text to parse such as "10:15:30+01:00", not null
* @return the parsed local time, not null
* @throws DateTimeParseException if the text cannot be parsed
*/
public static OffsetTime parse(CharSequence text) {
return parse(text, DateTimeFormatter.ISO_OFFSET_TIME);
}
/**
* Obtains an instance of {@code OffsetTime} from a text string using a specific formatter.
* <p>
* The text is parsed using the formatter, returning a time.
*
* @param text the text to parse, not null
* @param formatter the formatter to use, not null
* @return the parsed offset time, not null
* @throws DateTimeParseException if the text cannot be parsed
*/
public static OffsetTime parse(CharSequence text, DateTimeFormatter formatter) {
Objects.requireNonNull(formatter, "formatter");
return formatter.parse(text, OffsetTime::from);
}
//-----------------------------------------------------------------------
/**
* Constructor.
*
* @param time the local time, not null
* @param offset the zone offset, not null
*/
private OffsetTime(LocalTime time, ZoneOffset offset) {
this.time = Objects.requireNonNull(time, "time");
this.offset = Objects.requireNonNull(offset, "offset");
}
/**
* Returns a new time based on this one, returning {@code this} where possible.
*
* @param time the time to create with, not null
* @param offset the zone offset to create with, not null
*/
private OffsetTime with(LocalTime time, ZoneOffset offset) {
if (this.time == time && this.offset.equals(offset)) {
return this;
}
return new OffsetTime(time, offset);
}
//-----------------------------------------------------------------------
/**
* Checks if the specified field is supported.
* <p>
* This checks if this time can be queried for the specified field.
* If false, then calling the {@link #range(TemporalField) range},
* {@link #get(TemporalField) get} and {@link #with(TemporalField, long)}
* methods will throw an exception.
* <p>
* If the field is a {@link ChronoField} then the query is implemented here.
* The supported fields are:
* <ul>
* <li>{@code NANO_OF_SECOND}
* <li>{@code NANO_OF_DAY}
* <li>{@code MICRO_OF_SECOND}
* <li>{@code MICRO_OF_DAY}
* <li>{@code MILLI_OF_SECOND}
* <li>{@code MILLI_OF_DAY}
* <li>{@code SECOND_OF_MINUTE}
* <li>{@code SECOND_OF_DAY}
* <li>{@code MINUTE_OF_HOUR}
* <li>{@code MINUTE_OF_DAY}
* <li>{@code HOUR_OF_AMPM}
* <li>{@code CLOCK_HOUR_OF_AMPM}
* <li>{@code HOUR_OF_DAY}
* <li>{@code CLOCK_HOUR_OF_DAY}
* <li>{@code AMPM_OF_DAY}
* <li>{@code OFFSET_SECONDS}
* </ul>
* All other {@code ChronoField} instances will return false.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}
* passing {@code this} as the argument.
* Whether the field is supported is determined by the field.
*
* @param field the field to check, null returns false
* @return true if the field is supported on this time, false if not
*/
@Override
public boolean isSupported(TemporalField field) {
if (field instanceof ChronoField) {
return field.isTimeBased() || field == OFFSET_SECONDS;
}
return field != null && field.isSupportedBy(this);
}
/**
* Checks if the specified unit is supported.
* <p>
* This checks if the specified unit can be added to, or subtracted from, this date-time.
* If false, then calling the {@link #plus(long, TemporalUnit)} and
* {@link #minus(long, TemporalUnit) minus} methods will throw an exception.
* <p>
* If the unit is a {@link ChronoUnit} then the query is implemented here.
* The supported units are:
* <ul>
* <li>{@code NANOS}
* <li>{@code MICROS}
* <li>{@code MILLIS}
* <li>{@code SECONDS}
* <li>{@code MINUTES}
* <li>{@code HOURS}
* <li>{@code HALF_DAYS}
* </ul>
* All other {@code ChronoUnit} instances will return false.
* <p>
* If the unit is not a {@code ChronoUnit}, then the result of this method
* is obtained by invoking {@code TemporalUnit.isSupportedBy(Temporal)}
* passing {@code this} as the argument.
* Whether the unit is supported is determined by the unit.
*
* @param unit the unit to check, null returns false
* @return true if the unit can be added/subtracted, false if not
*/
@Override // override for Javadoc
public boolean isSupported(TemporalUnit unit) {
if (unit instanceof ChronoUnit) {
return unit.isTimeBased();
}
return unit != null && unit.isSupportedBy(this);
}
//-----------------------------------------------------------------------
/**
* Gets the range of valid values for the specified field.
* <p>
* The range object expresses the minimum and maximum valid values for a field.
* This time is used to enhance the accuracy of the returned range.
* If it is not possible to return the range, because the field is not supported
* or for some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link #isSupported(TemporalField) supported fields} will return
* appropriate range instances.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)}
* passing {@code this} as the argument.
* Whether the range can be obtained is determined by the field.
*
* @param field the field to query the range for, not null
* @return the range of valid values for the field, not null
* @throws DateTimeException if the range for the field cannot be obtained
* @throws UnsupportedTemporalTypeException if the field is not supported
*/
@Override
public ValueRange range(TemporalField field) {
if (field instanceof ChronoField) {
if (field == OFFSET_SECONDS) {
return field.range();
}
return time.range(field);
}
return field.rangeRefinedBy(this);
}
/**
* Gets the value of the specified field from this time as an {@code int}.
* <p>
* This queries this time for the value for the specified field.
* The returned value will always be within the valid range of values for the field.
* If it is not possible to return the value, because the field is not supported
* or for some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this time, except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY}
* which are too large to fit in an {@code int} and throw a {@code DateTimeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}
* passing {@code this} as the argument. Whether the value can be obtained,
* and what the value represents, is determined by the field.
*
* @param field the field to get, not null
* @return the value for the field
* @throws DateTimeException if a value for the field cannot be obtained or
* the value is outside the range of valid values for the field
* @throws UnsupportedTemporalTypeException if the field is not supported or
* the range of values exceeds an {@code int}
* @throws ArithmeticException if numeric overflow occurs
*/
@Override // override for Javadoc
public int get(TemporalField field) {
return Temporal.super.get(field);
}
/**
* Gets the value of the specified field from this time as a {@code long}.
* <p>
* This queries this time for the value for the specified field.
* If it is not possible to return the value, because the field is not supported
* or for some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this time.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}
* passing {@code this} as the argument. Whether the value can be obtained,
* and what the value represents, is determined by the field.
*
* @param field the field to get, not null
* @return the value for the field
* @throws DateTimeException if a value for the field cannot be obtained
* @throws UnsupportedTemporalTypeException if the field is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public long getLong(TemporalField field) {
if (field instanceof ChronoField) {
if (field == OFFSET_SECONDS) {
return offset.getTotalSeconds();
}
return time.getLong(field);
}
return field.getFrom(this);
}
//-----------------------------------------------------------------------
/**
* Gets the zone offset, such as '+01:00'.
* <p>
* This is the offset of the local time from UTC/Greenwich.
*
* @return the zone offset, not null
*/
public ZoneOffset getOffset() {
return offset;
}
/**
* Returns a copy of this {@code OffsetTime} with the specified offset ensuring
* that the result has the same local time.
* <p>
* This method returns an object with the same {@code LocalTime} and the specified {@code ZoneOffset}.
* No calculation is needed or performed.
* For example, if this time represents {@code 10:30+02:00} and the offset specified is
* {@code +03:00}, then this method will return {@code 10:30+03:00}.
* <p>
* To take into account the difference between the offsets, and adjust the time fields,
* use {@link #withOffsetSameInstant}.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param offset the zone offset to change to, not null
* @return an {@code OffsetTime} based on this time with the requested offset, not null
*/
public OffsetTime withOffsetSameLocal(ZoneOffset offset) {
return offset != null && offset.equals(this.offset) ? this : new OffsetTime(time, offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the specified offset ensuring
* that the result is at the same instant on an implied day.
* <p>
* This method returns an object with the specified {@code ZoneOffset} and a {@code LocalTime}
* adjusted by the difference between the two offsets.
* This will result in the old and new objects representing the same instant an an implied day.
* This is useful for finding the local time in a different offset.
* For example, if this time represents {@code 10:30+02:00} and the offset specified is
* {@code +03:00}, then this method will return {@code 11:30+03:00}.
* <p>
* To change the offset without adjusting the local time use {@link #withOffsetSameLocal}.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param offset the zone offset to change to, not null
* @return an {@code OffsetTime} based on this time with the requested offset, not null
*/
public OffsetTime withOffsetSameInstant(ZoneOffset offset) {
if (offset.equals(this.offset)) {
return this;
}
int difference = offset.getTotalSeconds() - this.offset.getTotalSeconds();
LocalTime adjusted = time.plusSeconds(difference);
return new OffsetTime(adjusted, offset);
}
//-----------------------------------------------------------------------
/**
* Gets the {@code LocalTime} part of this date-time.
* <p>
* This returns a {@code LocalTime} with the same hour, minute, second and
* nanosecond as this date-time.
*
* @return the time part of this date-time, not null
*/
public LocalTime toLocalTime() {
return time;
}
//-----------------------------------------------------------------------
/**
* Gets the hour-of-day field.
*
* @return the hour-of-day, from 0 to 23
*/
public int getHour() {
return time.getHour();
}
/**
* Gets the minute-of-hour field.
*
* @return the minute-of-hour, from 0 to 59
*/
public int getMinute() {
return time.getMinute();
}
/**
* Gets the second-of-minute field.
*
* @return the second-of-minute, from 0 to 59
*/
public int getSecond() {
return time.getSecond();
}
/**
* Gets the nano-of-second field.
*
* @return the nano-of-second, from 0 to 999,999,999
*/
public int getNano() {
return time.getNano();
}
//-----------------------------------------------------------------------
/**
* Returns an adjusted copy of this time.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the time adjusted.
* The adjustment takes place using the specified adjuster strategy object.
* Read the documentation of the adjuster to understand what adjustment will be made.
* <p>
* A simple adjuster might simply set the one of the fields, such as the hour field.
* A more complex adjuster might set the time to the last hour of the day.
* <p>
* The classes {@link LocalTime} and {@link ZoneOffset} implement {@code TemporalAdjuster},
* thus this method can be used to change the time or offset:
* <pre>
* result = offsetTime.with(time);
* result = offsetTime.with(offset);
* </pre>
* <p>
* The result of this method is obtained by invoking the
* {@link TemporalAdjuster#adjustInto(Temporal)} method on the
* specified adjuster passing {@code this} as the argument.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param adjuster the adjuster to use, not null
* @return an {@code OffsetTime} based on {@code this} with the adjustment made, not null
* @throws DateTimeException if the adjustment cannot be made
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime with(TemporalAdjuster adjuster) {
// optimizations
if (adjuster instanceof LocalTime) {
return with((LocalTime) adjuster, offset);
} else if (adjuster instanceof ZoneOffset) {
return with(time, (ZoneOffset) adjuster);
} else if (adjuster instanceof OffsetTime) {
return (OffsetTime) adjuster;
}
return (OffsetTime) adjuster.adjustInto(this);
}
/**
* Returns a copy of this time with the specified field set to a new value.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the value
* for the specified field changed.
* This can be used to change any supported field, such as the hour, minute or second.
* If it is not possible to set the value, because the field is not supported or for
* some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoField} then the adjustment is implemented here.
* <p>
* The {@code OFFSET_SECONDS} field will return a time with the specified offset.
* The local time is unaltered. If the new offset value is outside the valid range
* then a {@code DateTimeException} will be thrown.
* <p>
* The other {@link #isSupported(TemporalField) supported fields} will behave as per
* the matching method on {@link LocalTime#with(TemporalField, long)} LocalTime}.
* In this case, the offset is not part of the calculation and will be unchanged.
* <p>
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}
* passing {@code this} as the argument. In this case, the field determines
* whether and how to adjust the instant.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param field the field to set in the result, not null
* @param newValue the new value of the field in the result
* @return an {@code OffsetTime} based on {@code this} with the specified field set, not null
* @throws DateTimeException if the field cannot be set
* @throws UnsupportedTemporalTypeException if the field is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime with(TemporalField field, long newValue) {
if (field instanceof ChronoField) {
if (field == OFFSET_SECONDS) {
ChronoField f = (ChronoField) field;
return with(time, ZoneOffset.ofTotalSeconds(f.checkValidIntValue(newValue)));
}
return with(time.with(field, newValue), offset);
}
return field.adjustInto(this, newValue);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this {@code OffsetTime} with the hour-of-day value altered.
* <p>
* The offset does not affect the calculation and will be the same in the result.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param hour the hour-of-day to set in the result, from 0 to 23
* @return an {@code OffsetTime} based on this time with the requested hour, not null
* @throws DateTimeException if the hour value is invalid
*/
public OffsetTime withHour(int hour) {
return with(time.withHour(hour), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the minute-of-hour value altered.
* <p>
* The offset does not affect the calculation and will be the same in the result.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param minute the minute-of-hour to set in the result, from 0 to 59
* @return an {@code OffsetTime} based on this time with the requested minute, not null
* @throws DateTimeException if the minute value is invalid
*/
public OffsetTime withMinute(int minute) {
return with(time.withMinute(minute), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the second-of-minute value altered.
* <p>
* The offset does not affect the calculation and will be the same in the result.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param second the second-of-minute to set in the result, from 0 to 59
* @return an {@code OffsetTime} based on this time with the requested second, not null
* @throws DateTimeException if the second value is invalid
*/
public OffsetTime withSecond(int second) {
return with(time.withSecond(second), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the nano-of-second value altered.
* <p>
* The offset does not affect the calculation and will be the same in the result.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param nanoOfSecond the nano-of-second to set in the result, from 0 to 999,999,999
* @return an {@code OffsetTime} based on this time with the requested nanosecond, not null
* @throws DateTimeException if the nanos value is invalid
*/
public OffsetTime withNano(int nanoOfSecond) {
return with(time.withNano(nanoOfSecond), offset);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this {@code OffsetTime} with the time truncated.
* <p>
* Truncation returns a copy of the original time with fields
* smaller than the specified unit set to zero.
* For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit
* will set the second-of-minute and nano-of-second field to zero.
* <p>
* The unit must have a {@linkplain TemporalUnit#getDuration() duration}
* that divides into the length of a standard day without remainder.
* This includes all supplied time units on {@link ChronoUnit} and
* {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
* <p>
* The offset does not affect the calculation and will be the same in the result.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param unit the unit to truncate to, not null
* @return an {@code OffsetTime} based on this time with the time truncated, not null
* @throws DateTimeException if unable to truncate
* @throws UnsupportedTemporalTypeException if the unit is not supported
*/
public OffsetTime truncatedTo(TemporalUnit unit) {
return with(time.truncatedTo(unit), offset);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this time with the specified amount added.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the specified amount added.
* The amount is typically {@link Duration} but may be any other type implementing
* the {@link TemporalAmount} interface.
* <p>
* The calculation is delegated to the amount object by calling
* {@link TemporalAmount#addTo(Temporal)}. The amount implementation is free
* to implement the addition in any way it wishes, however it typically
* calls back to {@link #plus(long, TemporalUnit)}. Consult the documentation
* of the amount implementation to determine if it can be successfully added.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param amountToAdd the amount to add, not null
* @return an {@code OffsetTime} based on this time with the addition made, not null
* @throws DateTimeException if the addition cannot be made
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime plus(TemporalAmount amountToAdd) {
return (OffsetTime) amountToAdd.addTo(this);
}
/**
* Returns a copy of this time with the specified amount added.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the amount
* in terms of the unit added. If it is not possible to add the amount, because the
* unit is not supported or for some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoUnit} then the addition is implemented by
* {@link LocalTime#plus(long, TemporalUnit)}.
* The offset is not part of the calculation and will be unchanged in the result.
* <p>
* If the field is not a {@code ChronoUnit}, then the result of this method
* is obtained by invoking {@code TemporalUnit.addTo(Temporal, long)}
* passing {@code this} as the argument. In this case, the unit determines
* whether and how to perform the addition.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param amountToAdd the amount of the unit to add to the result, may be negative
* @param unit the unit of the amount to add, not null
* @return an {@code OffsetTime} based on this time with the specified amount added, not null
* @throws DateTimeException if the addition cannot be made
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime plus(long amountToAdd, TemporalUnit unit) {
if (unit instanceof ChronoUnit) {
return with(time.plus(amountToAdd, unit), offset);
}
return unit.addTo(this, amountToAdd);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this {@code OffsetTime} with the specified period in hours added.
* <p>
* This adds the specified number of hours to this time, returning a new time.
* The calculation wraps around midnight.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param hours the hours to add, may be negative
* @return an {@code OffsetTime} based on this time with the hours added, not null
*/
public OffsetTime plusHours(long hours) {
return with(time.plusHours(hours), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the specified period in minutes added.
* <p>
* This adds the specified number of minutes to this time, returning a new time.
* The calculation wraps around midnight.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param minutes the minutes to add, may be negative
* @return an {@code OffsetTime} based on this time with the minutes added, not null
*/
public OffsetTime plusMinutes(long minutes) {
return with(time.plusMinutes(minutes), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the specified period in seconds added.
* <p>
* This adds the specified number of seconds to this time, returning a new time.
* The calculation wraps around midnight.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param seconds the seconds to add, may be negative
* @return an {@code OffsetTime} based on this time with the seconds added, not null
*/
public OffsetTime plusSeconds(long seconds) {
return with(time.plusSeconds(seconds), offset);
}
/**
* Returns a copy of this {@code OffsetTime} with the specified period in nanoseconds added.
* <p>
* This adds the specified number of nanoseconds to this time, returning a new time.
* The calculation wraps around midnight.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param nanos the nanos to add, may be negative
* @return an {@code OffsetTime} based on this time with the nanoseconds added, not null
*/
public OffsetTime plusNanos(long nanos) {
return with(time.plusNanos(nanos), offset);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this time with the specified amount subtracted.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the specified amount subtracted.
* The amount is typically {@link Duration} but may be any other type implementing
* the {@link TemporalAmount} interface.
* <p>
* The calculation is delegated to the amount object by calling
* {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
* to implement the subtraction in any way it wishes, however it typically
* calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
* of the amount implementation to determine if it can be successfully subtracted.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param amountToSubtract the amount to subtract, not null
* @return an {@code OffsetTime} based on this time with the subtraction made, not null
* @throws DateTimeException if the subtraction cannot be made
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime minus(TemporalAmount amountToSubtract) {
return (OffsetTime) amountToSubtract.subtractFrom(this);
}
/**
* Returns a copy of this time with the specified amount subtracted.
* <p>
* This returns an {@code OffsetTime}, based on this one, with the amount
* in terms of the unit subtracted. If it is not possible to subtract the amount,
* because the unit is not supported or for some other reason, an exception is thrown.
* <p>
* This method is equivalent to {@link #plus(long, TemporalUnit)} with the amount negated.
* See that method for a full description of how addition, and thus subtraction, works.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param amountToSubtract the amount of the unit to subtract from the result, may be negative
* @param unit the unit of the amount to subtract, not null
* @return an {@code OffsetTime} based on this time with the specified amount subtracted, not null
* @throws DateTimeException if the subtraction cannot be made
* @throws UnsupportedTemporalTypeException if the unit is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public OffsetTime minus(long amountToSubtract, TemporalUnit unit) {
return (amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit) : plus(-amountToSubtract, unit));
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this {@code OffsetTime} with the specified period in hours subtracted.
* <p>
* This subtracts the specified number of hours from this time, returning a new time.