ICU 59.1  59.1
dtitvfmt.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************************
4 * Copyright (C) 2008-2016, International Business Machines Corporation and
5 * others. All Rights Reserved.
6 *******************************************************************************
7 *
8 * File DTITVFMT.H
9 *
10 *******************************************************************************
11 */
12 
13 #ifndef __DTITVFMT_H__
14 #define __DTITVFMT_H__
15 
16 
17 #include "unicode/utypes.h"
18 
24 #if !UCONFIG_NO_FORMATTING
25 
26 #include "unicode/ucal.h"
27 #include "unicode/smpdtfmt.h"
28 #include "unicode/dtintrv.h"
29 #include "unicode/dtitvinf.h"
30 #include "unicode/dtptngen.h"
31 
33 
34 
35 
223 public:
224 
238  static DateIntervalFormat* U_EXPORT2 createInstance(
239  const UnicodeString& skeleton,
240  UErrorCode& status);
241 
276  static DateIntervalFormat* U_EXPORT2 createInstance(
277  const UnicodeString& skeleton,
278  const Locale& locale,
279  UErrorCode& status);
280 
296  static DateIntervalFormat* U_EXPORT2 createInstance(
297  const UnicodeString& skeleton,
298  const DateIntervalInfo& dtitvinf,
299  UErrorCode& status);
300 
341  static DateIntervalFormat* U_EXPORT2 createInstance(
342  const UnicodeString& skeleton,
343  const Locale& locale,
344  const DateIntervalInfo& dtitvinf,
345  UErrorCode& status);
346 
351  virtual ~DateIntervalFormat();
352 
359  virtual Format* clone(void) const;
360 
368  virtual UBool operator==(const Format& other) const;
369 
377  UBool operator!=(const Format& other) const;
378 
379 
380  using Format::format;
381 
401  virtual UnicodeString& format(const Formattable& obj,
402  UnicodeString& appendTo,
403  FieldPosition& fieldPosition,
404  UErrorCode& status) const ;
405 
406 
407 
423  UnicodeString& format(const DateInterval* dtInterval,
424  UnicodeString& appendTo,
425  FieldPosition& fieldPosition,
426  UErrorCode& status) const ;
427 
428 
452  UnicodeString& format(Calendar& fromCalendar,
453  Calendar& toCalendar,
454  UnicodeString& appendTo,
455  FieldPosition& fieldPosition,
456  UErrorCode& status) const ;
457 
484  virtual void parseObject(const UnicodeString& source,
485  Formattable& result,
486  ParsePosition& parse_pos) const;
487 
488 
495  const DateIntervalInfo* getDateIntervalInfo(void) const;
496 
497 
504  void setDateIntervalInfo(const DateIntervalInfo& newIntervalPatterns,
505  UErrorCode& status);
506 
507 
519  const DateFormat* getDateFormat(void) const;
520 
526  virtual const TimeZone& getTimeZone(void) const;
527 
534  virtual void adoptTimeZone(TimeZone* zoneToAdopt);
535 
541  virtual void setTimeZone(const TimeZone& zone);
542 
554  static UClassID U_EXPORT2 getStaticClassID(void);
555 
567  virtual UClassID getDynamicClassID(void) const;
568 
569 protected:
570 
576 
582 
583 private:
584 
585  /*
586  * This is for ICU internal use only. Please do not use.
587  * Save the interval pattern information.
588  * Interval pattern consists of 2 single date patterns and the separator.
589  * For example, interval pattern "MMM d - MMM d, yyyy" consists
590  * a single date pattern "MMM d", another single date pattern "MMM d, yyyy",
591  * and a separator "-".
592  * The pattern is divided into 2 parts. For above example,
593  * the first part is "MMM d - ", and the second part is "MMM d, yyyy".
594  * Also, the first date appears in an interval pattern could be
595  * the earlier date or the later date.
596  * And such information is saved in the interval pattern as well.
597  */
598  struct PatternInfo {
599  UnicodeString firstPart;
600  UnicodeString secondPart;
614  UBool laterDateFirst;
615  };
616 
617 
623 
642  DateIntervalFormat(const Locale& locale, DateIntervalInfo* dtItvInfo,
643  const UnicodeString* skeleton, UErrorCode& status);
644 
645 
658  static DateIntervalFormat* U_EXPORT2 create(const Locale& locale,
659  DateIntervalInfo* dtitvinf,
660  const UnicodeString* skeleton,
661  UErrorCode& status);
662 
683  static void
684  adjustPosition(UnicodeString& combiningPattern, // has {0} and {1} in it
685  UnicodeString& pat0, FieldPosition& pos0, // pattern and pos corresponding to {0}
686  UnicodeString& pat1, FieldPosition& pos1, // pattern and pos corresponding to {1}
687  FieldPosition& posResult);
688 
689 
712  UnicodeString& fallbackFormat(Calendar& fromCalendar,
713  Calendar& toCalendar,
714  UBool fromToOnSameDay,
715  UnicodeString& appendTo,
716  FieldPosition& pos,
717  UErrorCode& status) const;
718 
719 
720 
755  void initializePattern(UErrorCode& status);
756 
757 
758 
766  void setFallbackPattern(UCalendarDateFields field,
767  const UnicodeString& skeleton,
768  UErrorCode& status);
769 
770 
771 
796  static void U_EXPORT2 getDateTimeSkeleton(const UnicodeString& skeleton,
797  UnicodeString& date,
798  UnicodeString& normalizedDate,
799  UnicodeString& time,
800  UnicodeString& normalizedTime);
801 
802 
803 
827  UBool setSeparateDateTimePtn(const UnicodeString& dateSkeleton,
828  const UnicodeString& timeSkeleton);
829 
830 
831 
832 
856  UBool setIntervalPattern(UCalendarDateFields field,
857  const UnicodeString* skeleton,
858  const UnicodeString* bestSkeleton,
859  int8_t differenceInfo,
860  UnicodeString* extendedSkeleton = NULL,
861  UnicodeString* extendedBestSkeleton = NULL);
862 
891  static void U_EXPORT2 adjustFieldWidth(
892  const UnicodeString& inputSkeleton,
893  const UnicodeString& bestMatchSkeleton,
894  const UnicodeString& bestMatchIntervalPattern,
895  int8_t differenceInfo,
896  UnicodeString& adjustedIntervalPattern);
897 
909  void concatSingleDate2TimeInterval(UnicodeString& format,
910  const UnicodeString& datePattern,
911  UCalendarDateFields field,
912  UErrorCode& status);
913 
920  static UBool U_EXPORT2 fieldExistsInSkeleton(UCalendarDateFields field,
921  const UnicodeString& skeleton);
922 
923 
929  static int32_t U_EXPORT2 splitPatternInto2Part(const UnicodeString& intervalPattern);
930 
931 
937  void setIntervalPattern(UCalendarDateFields field,
938  const UnicodeString& intervalPattern);
939 
940 
947  void setIntervalPattern(UCalendarDateFields field,
948  const UnicodeString& intervalPattern,
949  UBool laterDateFirst);
950 
951 
961  void setPatternInfo(UCalendarDateFields field,
962  const UnicodeString* firstPart,
963  const UnicodeString* secondPart,
964  UBool laterDateFirst);
965 
991  UnicodeString& formatImpl(Calendar& fromCalendar,
992  Calendar& toCalendar,
993  UnicodeString& appendTo,
994  FieldPosition& fieldPosition,
995  UErrorCode& status) const ;
996 
997 
998  // from calendar field to pattern letter
999  static const char16_t fgCalendarFieldToPatternLetter[];
1000 
1001 
1005  DateIntervalInfo* fInfo;
1006 
1010  SimpleDateFormat* fDateFormat;
1011 
1017  Calendar* fFromCalendar;
1018  Calendar* fToCalendar;
1019 
1020  Locale fLocale;
1021 
1025  UnicodeString fSkeleton;
1026  PatternInfo fIntervalPatterns[DateIntervalInfo::kIPI_MAX_INDEX];
1027 
1031  UnicodeString* fDatePattern;
1032  UnicodeString* fTimePattern;
1033  UnicodeString* fDateTimeFormat;
1034 };
1035 
1036 inline UBool
1038  return !operator==(other);
1039 }
1040 
1042 
1043 #endif /* #if !UCONFIG_NO_FORMATTING */
1044 
1045 #endif // _DTITVFMT_H__
1046 //eof
Base class for all formats.
Definition: format.h:96
UCalendarDateFields
Possible fields in a UCalendar.
Definition: ucal.h:185
DateIntervalFormat is a class for formatting and parsing date intervals in a language-independent man...
Definition: dtitvfmt.h:222
UBool operator!=(const Format &other) const
Return true if the given Format objects are not semantically equal.
Definition: format.h:121
C API: Calendar.
UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
Formats an object to produce a string.
C++ API: Date/Time Pattern Generator.
DateIntervalInfo is a public class for encapsulating localizable date time interval patterns...
Definition: dtitvinf.h:153
Calendar is an abstract base class for converting between a UDate object and a set of integer fields ...
Definition: calendar.h:202
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:93
virtual Format * clone() const =0
Clone this object polymorphically.
TimeZone represents a time zone offset, and also figures out daylight savings.
Definition: timezone.h:131
This class represents a date interval.
Definition: dtintrv.h:34
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:360
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:131
C++ API: Format and parse dates in a language-independent manner.
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:218
#define NULL
Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
Definition: utypes.h:188
virtual UClassID getDynamicClassID() const
ICU4C "poor man's RTTI", returns a UClassID for the actual ICU class.
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
C++ API: Date Interval data type.
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:396
SimpleDateFormat is a concrete class for formatting and parsing dates in a language-independent manne...
Definition: smpdtfmt.h:719
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:108
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:49
DateFormat is an abstract class for a family of classes that convert dates and times from their inter...
Definition: datefmt.h:149
virtual UBool operator==(const Format &other) const =0
Return true if the given Format objects are semantically equal.
virtual void parseObject(const UnicodeString &source, Formattable &result, ParsePosition &parse_pos) const =0
Parse a string to produce an object.
Basic definitions for ICU, for both C and C++ APIs.
C++ API: Date/Time interval patterns for formatting date/time interval.
Format & operator=(const Format &)
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:296
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:68
int8_t UBool
The ICU boolean type.
Definition: umachine.h:236
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:188