ICU 56 update step 1

source/i18n/unicode/dtitvfmt.h

 /********************************************************************************
-* Copyright (C) 2008-2013, International Business Machines Corporation and
+* Copyright (C) 2008-2013,2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File DTITVFMT.H
 *
 *******************************************************************************
 */
 
 #ifndef __DTITVFMT_H__
 #define __DTITVFMT_H__
@@ skipping 73 matching lines @@
  * important, such as MMM, MMMM, and MMMMM; EEE and EEEE,
  * and the field's pattern letter length is honored.
  *
  * For the digit calendar fields,  such as M or MM, d or dd, yy or yyyy,
  * the field pattern length is ignored and the best match, which is defined
  * in date time patterns, will be returned without honor the field pattern
  * letter length in skeleton.
  *
  * <P>
  * The calendar fields we support for interval formatting are:
- * year, month, date, day-of-week, am-pm, hour, hour-of-day, and minute.
+ * year, month, date, day-of-week, am-pm, hour, hour-of-day, minute, and second
+ * (though we do not currently have specific intervalFormat date for skeletons
+ * with seconds).
  * Those calendar fields can be defined in the following order:
- * year >  month > date > hour (in day) >  minute
+ * year >  month > date > hour (in day) >  minute > second
  *
  * The largest different calendar fields between 2 calendars is the
  * first different calendar field in above order.
  *
  * For example: the largest different calendar fields between "Jan 10, 2007"
  * and "Feb 20, 2008" is year.
  *
  * <P>
  * For other calendar fields, the compact interval formatting is not
  * supported. And the interval format will be fall back to fall-back
@@ skipping 271 matching lines @@
      * objects with a DateInterval type.
      * If a the Formattable object type is not a DateInterval,
      * then it returns a failing UErrorCode.
      *
      * @param obj               The object to format.
      *                          Must be a DateInterval.
      * @param appendTo          Output parameter to receive result.
      *                          Result is appended to existing contents.
      * @param fieldPosition     On input: an alignment field, if desired.
      *                          On output: the offsets of the alignment field.
+     *                          There may be multiple instances of a given field type
+     *                          in an interval format; in this case the fieldPosition
+     *                          offsets refer to the first instance.
      * @param status            Output param filled with success/failure status.
      * @return                  Reference to 'appendTo' parameter.
      * @stable ICU 4.0
      */
     virtual UnicodeString& format(const Formattable& obj,
                                   UnicodeString& appendTo,
                                   FieldPosition& fieldPosition,
                                   UErrorCode& status) const ;
 
 
 
     /**
      * Format a DateInterval to produce a string.
      *
      * @param dtInterval        DateInterval to be formatted.
      * @param appendTo          Output parameter to receive result.
      *                          Result is appended to existing contents.
      * @param fieldPosition     On input: an alignment field, if desired.
      *                          On output: the offsets of the alignment field.
+     *                          There may be multiple instances of a given field type
+     *                          in an interval format; in this case the fieldPosition
+     *                          offsets refer to the first instance.
      * @param status            Output param filled with success/failure status.
      * @return                  Reference to 'appendTo' parameter.
      * @stable ICU 4.0
      */
     UnicodeString& format(const DateInterval* dtInterval,
                           UnicodeString& appendTo,
                           FieldPosition& fieldPosition,
                           UErrorCode& status) const ;
 
 
     /**
      * Format 2 Calendars to produce a string.
      *
      * Note: "fromCalendar" and "toCalendar" are not const,
      * since calendar is not const in  SimpleDateFormat::format(Calendar&),
      *
      * @param fromCalendar      calendar set to the from date in date interval
      *                          to be formatted into date interval string
      * @param toCalendar        calendar set to the to date in date interval
      *                          to be formatted into date interval string
      * @param appendTo          Output parameter to receive result.
      *                          Result is appended to existing contents.
      * @param fieldPosition     On input: an alignment field, if desired.
      *                          On output: the offsets of the alignment field.
+     *                          There may be multiple instances of a given field type
+     *                          in an interval format; in this case the fieldPosition
+     *                          offsets refer to the first instance.
      * @param status            Output param filled with success/failure status.
      *                          Caller needs to make sure it is SUCCESS
      *                          at the function entrance
      * @return                  Reference to 'appendTo' parameter.
      * @stable ICU 4.0
      */
     UnicodeString& format(Calendar& fromCalendar,
                           Calendar& toCalendar,
                           UnicodeString& appendTo,
                           FieldPosition& fieldPosition,
@@ skipping 192 matching lines @@
      * @param skeleton  the skeleton of this formatter.
      * @param status    Output param set to success/failure code.
      * @return          a date time interval formatter which the caller owns.
      */
     static DateIntervalFormat* U_EXPORT2 create(const Locale& locale,
                                                 DateIntervalInfo* dtitvinf,
                                                 const UnicodeString* skeleton,
                                                 UErrorCode& status);
 
     /**
-     * Create a simple date/time formatter from skeleton, given locale,
-     * and date time pattern generator.
-     *
-     * @param skeleton  the skeleton on which date format based.
-     * @param locale    the given locale.
-     * @param dtpng     the date time pattern generator.
-     * @param status    Output param to be set to success/failure code.
-     *                  If it is failure, the returned date formatter will
-     *                  be NULL.
-     * @return          a simple date formatter which the caller owns.
-     */
-    static SimpleDateFormat* U_EXPORT2 createSDFPatternInstance(
-                                        const UnicodeString& skeleton,
-                                        const Locale& locale,
-                                        DateTimePatternGenerator* dtpng,
-                                        UErrorCode& status);
-
-
-    /**
      *  Below are for generating interval patterns local to the formatter
      */
 
+    /**
+     * Provide an updated FieldPosition posResult based on two formats,
+     * the FieldPosition values for each of them, and the pattern used
+     * to combine them. The idea is for posResult to indicate the first
+     * instance (if any) of the specified field in the combined result,
+     * with correct offsets.
+     *
+     * @param combiningPattern  Pattern used to combine pat0 and pat1
+     * @param pat0              Formatted date/time value to replace {0}
+     * @param pos0              FieldPosition within pat0
+     * @param pat1              Formatted date/time value to replace {1}
+     * @param pos1              FieldPosition within pat1
+     * @param posResult         FieldPosition to be set to the correct
+     *                          position of the first field instance when
+     *                          pat0 and pat1 are combined using combiningPattern
+     */
+    static void
+    adjustPosition(UnicodeString& combiningPattern, // has {0} and {1} in it
+                   UnicodeString& pat0, FieldPosition& pos0, // pattern and pos corresponding to {0}
+                   UnicodeString& pat1, FieldPosition& pos1, // pattern and pos corresponding to {1}
+                   FieldPosition& posResult);
+
 
     /**
      * Format 2 Calendars using fall-back interval pattern
      *
      * The full pattern used in this fall-back format is the
      * full pattern of the date formatter.
      *
      * @param fromCalendar      calendar set to the from date in date interval
      *                          to be formatted into date interval string
      * @param toCalendar        calendar set to the to date in date interval
      *                          to be formatted into date interval string
+     * @param fromToOnSameDay   TRUE iff from and to dates are on the same day
+     *                          (any difference is in ampm/hours or below)
      * @param appendTo          Output parameter to receive result.
      *                          Result is appended to existing contents.
      * @param pos               On input: an alignment field, if desired.
      *                          On output: the offsets of the alignment field.
      * @param status            output param set to success/failure code on exit
      * @return                  Reference to 'appendTo' parameter.
      */
     UnicodeString& fallbackFormat(Calendar& fromCalendar,
                                   Calendar& toCalendar,
+                                  UBool fromToOnSameDay,
                                   UnicodeString& appendTo,
                                   FieldPosition& pos,
                                   UErrorCode& status) const;
 
 
 
     /**
      * Initialize interval patterns locale to this formatter
      *
      * This code is a bit complicated since
@@ skipping 170 matching lines @@
                             int8_t differenceInfo,
                             UnicodeString& adjustedIntervalPattern);
 
     /**
      * Concat a single date pattern with a time interval pattern,
      * set it into the intervalPatterns, while field is time field.
      * This is used to handle time interval patterns on skeleton with
      * both time and date. Present the date followed by
      * the range expression for the time.
      * @param format         date and time format
-     * @param formatLen      format string length
      * @param datePattern    date pattern
      * @param field          time calendar field: AM_PM, HOUR, MINUTE
      * @param status         output param set to success/failure code on exit
      */
-    void concatSingleDate2TimeInterval(const UChar* format,
-                                       int32_t formatLen,
+    void concatSingleDate2TimeInterval(UnicodeString& format,
                                        const UnicodeString& datePattern,
                                        UCalendarDateFields field,
                                        UErrorCode& status);
 
     /**
      * check whether a calendar field present in a skeleton.
      * @param field      calendar field need to check
      * @param skeleton   given skeleton on which to check the calendar field
      * @return           true if field present in a skeleton.
      */
@@ skipping 59 matching lines @@
     SimpleDateFormat*     fDateFormat;
 
     /**
      * The 2 calendars with the from and to date.
      * could re-use the calendar in fDateFormat,
      * but keeping 2 calendars make it clear and clean.
      */
     Calendar* fFromCalendar;
     Calendar* fToCalendar;
 
-    /**
-     * Date time pattern generator
-     */
-    DateTimePatternGenerator* fDtpng;
+    Locale fLocale;
 
     /**
-     * Following are interval information relavent (locale) to this formatter.
+     * Following are interval information relevant (locale) to this formatter.
      */
     UnicodeString fSkeleton;
     PatternInfo fIntervalPatterns[DateIntervalInfo::kIPI_MAX_INDEX];
+
+    /**
+     * Patterns for fallback formatting.
+     */
+    UnicodeString* fDatePattern;
+    UnicodeString* fTimePattern;
+    UnicodeString* fDateTimeFormat;
 };
 
 inline UBool
 DateIntervalFormat::operator!=(const Format& other) const  {
     return !operator==(other);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 #endif // _DTITVFMT_H__
 //eof