1 /*
   2  * Copyright (c) 2012, 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  * This file is available under and governed by the GNU General Public
  28  * License version 2 only, as published by the Free Software Foundation.
  29  * However, the following notice accompanied the original version of this
  30  * file:
  31  *
  32  * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos
  33  *
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions are met:
  38  *
  39  *  * Redistributions of source code must retain the above copyright notice,
  40  *    this list of conditions and the following disclaimer.
  41  *
  42  *  * Redistributions in binary form must reproduce the above copyright notice,
  43  *    this list of conditions and the following disclaimer in the documentation
  44  *    and/or other materials provided with the distribution.
  45  *
  46  *  * Neither the name of JSR-310 nor the names of its contributors
  47  *    may be used to endorse or promote products derived from this software
  48  *    without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  54  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  55  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  56  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  57  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  58  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  59  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  60  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61  */
  62 package java.time.format;
  63 
  64 import static java.time.temporal.ChronoField.EPOCH_DAY;
  65 import static java.time.temporal.ChronoField.INSTANT_SECONDS;
  66 import static java.time.temporal.ChronoField.OFFSET_SECONDS;
  67 
  68 import java.time.DateTimeException;
  69 import java.time.Instant;
  70 import java.time.ZoneId;
  71 import java.time.ZoneOffset;
  72 import java.time.chrono.ChronoLocalDate;
  73 import java.time.chrono.Chronology;
  74 import java.time.chrono.IsoChronology;
  75 import java.time.temporal.ChronoField;
  76 import java.time.temporal.TemporalAccessor;
  77 import java.time.temporal.TemporalField;
  78 import java.time.temporal.TemporalQueries;
  79 import java.time.temporal.TemporalQuery;
  80 import java.time.temporal.ValueRange;
  81 import java.util.Locale;
  82 import java.util.Objects;
  83 
  84 /**
  85  * Context object used during date and time printing.
  86  * <p>
  87  * This class provides a single wrapper to items used in the format.
  88  *
  89  * @implSpec
  90  * This class is a mutable context intended for use from a single thread.
  91  * Usage of the class is thread-safe within standard printing as the framework creates
  92  * a new instance of the class for each format and printing is single-threaded.
  93  *
  94  * @since 1.8
  95  */
  96 final class DateTimePrintContext {
  97 
  98     /**
  99      * The temporal being output.
 100      */
 101     private TemporalAccessor temporal;
 102     /**
 103      * The formatter, not null.
 104      */
 105     private DateTimeFormatter formatter;
 106     /**
 107      * Whether the current formatter is optional.
 108      */
 109     private int optional;
 110 
 111     /**
 112      * Creates a new instance of the context.
 113      *
 114      * @param temporal  the temporal object being output, not null
 115      * @param formatter  the formatter controlling the format, not null
 116      */
 117     DateTimePrintContext(TemporalAccessor temporal, DateTimeFormatter formatter) {
 118         super();
 119         this.temporal = adjust(temporal, formatter);
 120         this.formatter = formatter;
 121     }
 122 
 123     private static TemporalAccessor adjust(final TemporalAccessor temporal, DateTimeFormatter formatter) {
 124         // normal case first (early return is an optimization)
 125         Chronology overrideChrono = formatter.getChronology();
 126         ZoneId overrideZone = formatter.getZone();
 127         if (overrideChrono == null && overrideZone == null) {
 128             return temporal;
 129         }
 130 
 131         // ensure minimal change (early return is an optimization)
 132         Chronology temporalChrono = temporal.query(TemporalQueries.chronology());
 133         ZoneId temporalZone = temporal.query(TemporalQueries.zoneId());
 134         if (Objects.equals(overrideChrono, temporalChrono)) {
 135             overrideChrono = null;
 136         }
 137         if (Objects.equals(overrideZone, temporalZone)) {
 138             overrideZone = null;
 139         }
 140         if (overrideChrono == null && overrideZone == null) {
 141             return temporal;
 142         }
 143 
 144         // make adjustment
 145         final Chronology effectiveChrono = (overrideChrono != null ? overrideChrono : temporalChrono);
 146         if (overrideZone != null) {
 147             // if have zone and instant, calculation is simple, defaulting chrono if necessary
 148             if (temporal.isSupported(INSTANT_SECONDS)) {
 149                 Chronology chrono = Objects.requireNonNullElse(effectiveChrono, IsoChronology.INSTANCE);
 150                 return chrono.zonedDateTime(Instant.from(temporal), overrideZone);
 151             }
 152             // block changing zone on OffsetTime, and similar problem cases
 153             if (overrideZone.normalized() instanceof ZoneOffset && temporal.isSupported(OFFSET_SECONDS) &&
 154                     temporal.get(OFFSET_SECONDS) != overrideZone.getRules().getOffset(Instant.EPOCH).getTotalSeconds()) {
 155                 throw new DateTimeException("Unable to apply override zone '" + overrideZone +
 156                         "' because the temporal object being formatted has a different offset but" +
 157                         " does not represent an instant: " + temporal);
 158             }
 159         }
 160         final ZoneId effectiveZone = (overrideZone != null ? overrideZone : temporalZone);
 161         final ChronoLocalDate effectiveDate;
 162         if (overrideChrono != null) {
 163             if (temporal.isSupported(EPOCH_DAY)) {
 164                 effectiveDate = effectiveChrono.date(temporal);
 165             } else {
 166                 // check for date fields other than epoch-day, ignoring case of converting null to ISO
 167                 if (!(overrideChrono == IsoChronology.INSTANCE && temporalChrono == null)) {
 168                     for (ChronoField f : ChronoField.values()) {
 169                         if (f.isDateBased() && temporal.isSupported(f)) {
 170                             throw new DateTimeException("Unable to apply override chronology '" + overrideChrono +
 171                                     "' because the temporal object being formatted contains date fields but" +
 172                                     " does not represent a whole date: " + temporal);
 173                         }
 174                     }
 175                 }
 176                 effectiveDate = null;
 177             }
 178         } else {
 179             effectiveDate = null;
 180         }
 181 
 182         // combine available data
 183         // this is a non-standard temporal that is almost a pure delegate
 184         // this better handles map-like underlying temporal instances
 185         return new TemporalAccessor() {
 186             @Override
 187             public boolean isSupported(TemporalField field) {
 188                 if (effectiveDate != null && field.isDateBased()) {
 189                     return effectiveDate.isSupported(field);
 190                 }
 191                 return temporal.isSupported(field);
 192             }
 193             @Override
 194             public ValueRange range(TemporalField field) {
 195                 if (effectiveDate != null && field.isDateBased()) {
 196                     return effectiveDate.range(field);
 197                 }
 198                 return temporal.range(field);
 199             }
 200             @Override
 201             public long getLong(TemporalField field) {
 202                 if (effectiveDate != null && field.isDateBased()) {
 203                     return effectiveDate.getLong(field);
 204                 }
 205                 return temporal.getLong(field);
 206             }
 207             @SuppressWarnings("unchecked")
 208             @Override
 209             public <R> R query(TemporalQuery<R> query) {
 210                 if (query == TemporalQueries.chronology()) {
 211                     return (R) effectiveChrono;
 212                 }
 213                 if (query == TemporalQueries.zoneId()) {
 214                     return (R) effectiveZone;
 215                 }
 216                 if (query == TemporalQueries.precision()) {
 217                     return temporal.query(query);
 218                 }
 219                 return query.queryFrom(this);
 220             }
 221 
 222             @Override
 223             public String toString() {
 224                 return temporal +
 225                         (effectiveChrono != null ? " with chronology " + effectiveChrono : "") +
 226                         (effectiveZone != null ? " with zone " + effectiveZone : "");
 227             }
 228         };
 229     }
 230 
 231     //-----------------------------------------------------------------------
 232     /**
 233      * Gets the temporal object being output.
 234      *
 235      * @return the temporal object, not null
 236      */
 237     TemporalAccessor getTemporal() {
 238         return temporal;
 239     }
 240 
 241     /**
 242      * Gets the locale.
 243      * <p>
 244      * This locale is used to control localization in the format output except
 245      * where localization is controlled by the DecimalStyle.
 246      *
 247      * @return the locale, not null
 248      */
 249     Locale getLocale() {
 250         return formatter.getLocale();
 251     }
 252 
 253     /**
 254      * Gets the DecimalStyle.
 255      * <p>
 256      * The DecimalStyle controls the localization of numeric output.
 257      *
 258      * @return the DecimalStyle, not null
 259      */
 260     DecimalStyle getDecimalStyle() {
 261         return formatter.getDecimalStyle();
 262     }
 263 
 264     //-----------------------------------------------------------------------
 265     /**
 266      * Starts the printing of an optional segment of the input.
 267      */
 268     void startOptional() {
 269         this.optional++;
 270     }
 271 
 272     /**
 273      * Ends the printing of an optional segment of the input.
 274      */
 275     void endOptional() {
 276         this.optional--;
 277     }
 278 
 279     /**
 280      * Gets a value using a query.
 281      *
 282      * @param query  the query to use, not null
 283      * @return the result, null if not found and optional is true
 284      * @throws DateTimeException if the type is not available and the section is not optional
 285      */
 286     <R> R getValue(TemporalQuery<R> query) {
 287         R result = temporal.query(query);
 288         if (result == null && optional == 0) {
 289             throw new DateTimeException("Unable to extract " +
 290                     query + " from temporal " + temporal);
 291         }
 292         return result;
 293     }
 294 
 295     /**
 296      * Gets the value of the specified field.
 297      * <p>
 298      * This will return the value for the specified field.
 299      *
 300      * @param field  the field to find, not null
 301      * @return the value, null if not found and optional is true
 302      * @throws DateTimeException if the field is not available and the section is not optional
 303      */
 304     Long getValue(TemporalField field) {
 305         try {
 306             return temporal.getLong(field);
 307         } catch (DateTimeException ex) {
 308             if (optional > 0) {
 309                 return null;
 310             }
 311             throw ex;
 312         }
 313     }
 314 
 315     //-----------------------------------------------------------------------
 316     /**
 317      * Returns a string version of the context for debugging.
 318      *
 319      * @return a string representation of the context, not null
 320      */
 321     @Override
 322     public String toString() {
 323         return temporal.toString();
 324     }
 325 
 326 }
--- EOF ---