1/*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26/*
27 * Copyright (c) 2013, Stephen Colebourne & Michael Nascimento Santos
28 *
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions are met:
33 *
34 *  * Redistributions of source code must retain the above copyright notice,
35 *    this list of conditions and the following disclaimer.
36 *
37 *  * Redistributions in binary form must reproduce the above copyright notice,
38 *    this list of conditions and the following disclaimer in the documentation
39 *    and/or other materials provided with the distribution.
40 *
41 *  * Neither the name of JSR-310 nor the names of its contributors
42 *    may be used to endorse or promote products derived from this software
43 *    without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
46 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
47 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
48 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
49 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
50 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
53 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
54 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
55 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 */
57package java.time.chrono;
58
59import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
60import static java.time.temporal.ChronoUnit.DAYS;
61import static java.time.temporal.ChronoUnit.MONTHS;
62import static java.time.temporal.ChronoUnit.YEARS;
63
64import java.io.DataInput;
65import java.io.DataOutput;
66import java.io.IOException;
67import java.io.InvalidObjectException;
68import java.io.ObjectInputStream;
69import java.io.ObjectStreamException;
70import java.io.Serializable;
71import java.time.DateTimeException;
72import java.time.temporal.ChronoUnit;
73import java.time.temporal.Temporal;
74import java.time.temporal.TemporalAccessor;
75import java.time.temporal.TemporalAmount;
76import java.time.temporal.TemporalQueries;
77import java.time.temporal.TemporalUnit;
78import java.time.temporal.UnsupportedTemporalTypeException;
79import java.time.temporal.ValueRange;
80import java.util.List;
81import java.util.Objects;
82
83/**
84 * A period expressed in terms of a standard year-month-day calendar system.
85 * <p>
86 * This class is used by applications seeking to handle dates in non-ISO calendar systems.
87 * For example, the Japanese, Minguo, Thai Buddhist and others.
88 *
89 * @implSpec
90 * This class is immutable nad thread-safe.
91 *
92 * @since 1.8
93 */
94final class ChronoPeriodImpl
95        implements ChronoPeriod, Serializable {
96    // this class is only used by JDK chronology implementations and makes assumptions based on that fact
97
98    /**
99     * Serialization version.
100     */
101    private static final long serialVersionUID = 57387258289L;
102
103    /**
104     * The set of supported units.
105     */
106    private static final List<TemporalUnit> SUPPORTED_UNITS = List.of(YEARS, MONTHS, DAYS);
107
108    /**
109     * The chronology.
110     */
111    private final Chronology chrono;
112    /**
113     * The number of years.
114     */
115    final int years;
116    /**
117     * The number of months.
118     */
119    final int months;
120    /**
121     * The number of days.
122     */
123    final int days;
124
125    /**
126     * Creates an instance.
127     */
128    ChronoPeriodImpl(Chronology chrono, int years, int months, int days) {
129        Objects.requireNonNull(chrono, "chrono");
130        this.chrono = chrono;
131        this.years = years;
132        this.months = months;
133        this.days = days;
134    }
135
136    //-----------------------------------------------------------------------
137    @Override
138    public long get(TemporalUnit unit) {
139        if (unit == ChronoUnit.YEARS) {
140            return years;
141        } else if (unit == ChronoUnit.MONTHS) {
142            return months;
143        } else if (unit == ChronoUnit.DAYS) {
144            return days;
145        } else {
146            throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
147        }
148    }
149
150    @Override
151    public List<TemporalUnit> getUnits() {
152        return ChronoPeriodImpl.SUPPORTED_UNITS;
153    }
154
155    @Override
156    public Chronology getChronology() {
157        return chrono;
158    }
159
160    //-----------------------------------------------------------------------
161    @Override
162    public boolean isZero() {
163        return years == 0 && months == 0 && days == 0;
164    }
165
166    @Override
167    public boolean isNegative() {
168        return years < 0 || months < 0 || days < 0;
169    }
170
171    //-----------------------------------------------------------------------
172    @Override
173    public ChronoPeriod plus(TemporalAmount amountToAdd) {
174        ChronoPeriodImpl amount = validateAmount(amountToAdd);
175        return new ChronoPeriodImpl(
176                chrono,
177                Math.addExact(years, amount.years),
178                Math.addExact(months, amount.months),
179                Math.addExact(days, amount.days));
180    }
181
182    @Override
183    public ChronoPeriod minus(TemporalAmount amountToSubtract) {
184        ChronoPeriodImpl amount = validateAmount(amountToSubtract);
185        return new ChronoPeriodImpl(
186                chrono,
187                Math.subtractExact(years, amount.years),
188                Math.subtractExact(months, amount.months),
189                Math.subtractExact(days, amount.days));
190    }
191
192    /**
193     * Obtains an instance of {@code ChronoPeriodImpl} from a temporal amount.
194     *
195     * @param amount  the temporal amount to convert, not null
196     * @return the period, not null
197     */
198    private ChronoPeriodImpl validateAmount(TemporalAmount amount) {
199        Objects.requireNonNull(amount, "amount");
200        if (amount instanceof ChronoPeriodImpl == false) {
201            throw new DateTimeException("Unable to obtain ChronoPeriod from TemporalAmount: " + amount.getClass());
202        }
203        ChronoPeriodImpl period = (ChronoPeriodImpl) amount;
204        if (chrono.equals(period.getChronology()) == false) {
205            throw new ClassCastException("Chronology mismatch, expected: " + chrono.getId() + ", actual: " + period.getChronology().getId());
206        }
207        return period;
208    }
209
210    //-----------------------------------------------------------------------
211    @Override
212    public ChronoPeriod multipliedBy(int scalar) {
213        if (this.isZero() || scalar == 1) {
214            return this;
215        }
216        return new ChronoPeriodImpl(
217                chrono,
218                Math.multiplyExact(years, scalar),
219                Math.multiplyExact(months, scalar),
220                Math.multiplyExact(days, scalar));
221    }
222
223    //-----------------------------------------------------------------------
224    @Override
225    public ChronoPeriod normalized() {
226        long monthRange = monthRange();
227        if (monthRange > 0) {
228            long totalMonths = years * monthRange + months;
229            long splitYears = totalMonths / monthRange;
230            int splitMonths = (int) (totalMonths % monthRange);  // no overflow
231            if (splitYears == years && splitMonths == months) {
232                return this;
233            }
234            return new ChronoPeriodImpl(chrono, Math.toIntExact(splitYears), splitMonths, days);
235
236        }
237        return this;
238    }
239
240    /**
241     * Calculates the range of months.
242     *
243     * @return the month range, -1 if not fixed range
244     */
245    private long monthRange() {
246        ValueRange startRange = chrono.range(MONTH_OF_YEAR);
247        if (startRange.isFixed() && startRange.isIntValue()) {
248            return startRange.getMaximum() - startRange.getMinimum() + 1;
249        }
250        return -1;
251    }
252
253    //-------------------------------------------------------------------------
254    @Override
255    public Temporal addTo(Temporal temporal) {
256        validateChrono(temporal);
257        if (months == 0) {
258            if (years != 0) {
259                temporal = temporal.plus(years, YEARS);
260            }
261        } else {
262            long monthRange = monthRange();
263            if (monthRange > 0) {
264                temporal = temporal.plus(years * monthRange + months, MONTHS);
265            } else {
266                if (years != 0) {
267                    temporal = temporal.plus(years, YEARS);
268                }
269                temporal = temporal.plus(months, MONTHS);
270            }
271        }
272        if (days != 0) {
273            temporal = temporal.plus(days, DAYS);
274        }
275        return temporal;
276    }
277
278
279
280    @Override
281    public Temporal subtractFrom(Temporal temporal) {
282        validateChrono(temporal);
283        if (months == 0) {
284            if (years != 0) {
285                temporal = temporal.minus(years, YEARS);
286            }
287        } else {
288            long monthRange = monthRange();
289            if (monthRange > 0) {
290                temporal = temporal.minus(years * monthRange + months, MONTHS);
291            } else {
292                if (years != 0) {
293                    temporal = temporal.minus(years, YEARS);
294                }
295                temporal = temporal.minus(months, MONTHS);
296            }
297        }
298        if (days != 0) {
299            temporal = temporal.minus(days, DAYS);
300        }
301        return temporal;
302    }
303
304    /**
305     * Validates that the temporal has the correct chronology.
306     */
307    private void validateChrono(TemporalAccessor temporal) {
308        Objects.requireNonNull(temporal, "temporal");
309        Chronology temporalChrono = temporal.query(TemporalQueries.chronology());
310        if (temporalChrono != null && chrono.equals(temporalChrono) == false) {
311            throw new DateTimeException("Chronology mismatch, expected: " + chrono.getId() + ", actual: " + temporalChrono.getId());
312        }
313    }
314
315    //-----------------------------------------------------------------------
316    @Override
317    public boolean equals(Object obj) {
318        if (this == obj) {
319            return true;
320        }
321        if (obj instanceof ChronoPeriodImpl) {
322            ChronoPeriodImpl other = (ChronoPeriodImpl) obj;
323            return years == other.years && months == other.months &&
324                    days == other.days && chrono.equals(other.chrono);
325        }
326        return false;
327    }
328
329    @Override
330    public int hashCode() {
331        return (years + Integer.rotateLeft(months, 8) + Integer.rotateLeft(days, 16)) ^ chrono.hashCode();
332    }
333
334    //-----------------------------------------------------------------------
335    @Override
336    public String toString() {
337        if (isZero()) {
338            return getChronology().toString() + " P0D";
339        } else {
340            StringBuilder buf = new StringBuilder();
341            buf.append(getChronology().toString()).append(' ').append('P');
342            if (years != 0) {
343                buf.append(years).append('Y');
344            }
345            if (months != 0) {
346                buf.append(months).append('M');
347            }
348            if (days != 0) {
349                buf.append(days).append('D');
350            }
351            return buf.toString();
352        }
353    }
354
355    //-----------------------------------------------------------------------
356    /**
357     * Writes the Chronology using a
358     * <a href="../../../serialized-form.html#java.time.chrono.Ser">dedicated serialized form</a>.
359     * <pre>
360     *  out.writeByte(12);  // identifies this as a ChronoPeriodImpl
361     *  out.writeUTF(getId());  // the chronology
362     *  out.writeInt(years);
363     *  out.writeInt(months);
364     *  out.writeInt(days);
365     * </pre>
366     *
367     * @return the instance of {@code Ser}, not null
368     */
369    protected Object writeReplace() {
370        return new Ser(Ser.CHRONO_PERIOD_TYPE, this);
371    }
372
373    /**
374     * Defend against malicious streams.
375     *
376     * @param s the stream to read
377     * @throws InvalidObjectException always
378     */
379    private void readObject(ObjectInputStream s) throws ObjectStreamException {
380        throw new InvalidObjectException("Deserialization via serialization delegate");
381    }
382
383    void writeExternal(DataOutput out) throws IOException {
384        out.writeUTF(chrono.getId());
385        out.writeInt(years);
386        out.writeInt(months);
387        out.writeInt(days);
388    }
389
390    static ChronoPeriodImpl readExternal(DataInput in) throws IOException {
391        Chronology chrono = Chronology.of(in.readUTF());
392        int years = in.readInt();
393        int months = in.readInt();
394        int days = in.readInt();
395        return new ChronoPeriodImpl(chrono, years, months, days);
396    }
397
398}
399