icuSources/i18n/numparse_types.h

   1 // © 2018 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3
   4 #include "unicode/utypes.h"
   5
   6 #if !UCONFIG_NO_FORMATTING
   7 #ifndef __NUMPARSE_TYPES_H__
   8 #define __NUMPARSE_TYPES_H__
   9
  10 #include "unicode/uobject.h"
  11 #include "number_decimalquantity.h"
  12 #include "string_segment.h"
  13
  14 U_NAMESPACE_BEGIN
  15 namespace numparse {
  16 namespace impl {
  17
  18 // Forward-declarations
  19 class ParsedNumber;
  20
  21 typedef int32_t result_flags_t;
  22 typedef int32_t parse_flags_t;
  23
  24 /** Flags for the type result_flags_t */
  25 enum ResultFlags {
  26     FLAG_NEGATIVE = 0x0001,
  27     FLAG_PERCENT = 0x0002,
  28     FLAG_PERMILLE = 0x0004,
  29     FLAG_HAS_EXPONENT = 0x0008,
  30     // FLAG_HAS_DEFAULT_CURRENCY = 0x0010, // no longer used
  31     FLAG_HAS_DECIMAL_SEPARATOR = 0x0020,
  32     FLAG_NAN = 0x0040,
  33     FLAG_INFINITY = 0x0080,
  34     FLAG_FAIL = 0x0100,
  35 };
  36
  37 /** Flags for the type parse_flags_t */
  38 enum ParseFlags {
  39     PARSE_FLAG_IGNORE_CASE = 0x0001,
  40     PARSE_FLAG_MONETARY_SEPARATORS = 0x0002,
  41     PARSE_FLAG_STRICT_SEPARATORS = 0x0004,
  42     PARSE_FLAG_STRICT_GROUPING_SIZE = 0x0008,
  43     PARSE_FLAG_INTEGER_ONLY = 0x0010,
  44     PARSE_FLAG_GROUPING_DISABLED = 0x0020,
  45     // PARSE_FLAG_FRACTION_GROUPING_ENABLED = 0x0040, // see #10794
  46     PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES = 0x0080,
  47     PARSE_FLAG_USE_FULL_AFFIXES = 0x0100,
  48     PARSE_FLAG_EXACT_AFFIX = 0x0200,
  49     PARSE_FLAG_PLUS_SIGN_ALLOWED = 0x0400,
  50     // PARSE_FLAG_OPTIMIZE = 0x0800, // no longer used
  51     // PARSE_FLAG_FORCE_BIG_DECIMAL = 0x1000, // not used in ICU4C
  52     PARSE_FLAG_NO_FOREIGN_CURRENCY = 0x2000,
  53     PARSE_FLAG_ALLOW_INFINITE_RECURSION = 0x4000,
  54     PARSE_FLAG_STRICT_IGNORABLES = 0x8000,
  55     PARSE_FLAG_HAS_TRAIL_CURRENCY = 0x0800, // Apple <rdar://problem/51938595>
  56 };
  57
  58
  59 // TODO: Is this class worthwhile?
  60 template<int32_t stackCapacity>
  61 class CompactUnicodeString {
  62   public:
  63     CompactUnicodeString() {
  64         static_assert(stackCapacity > 0, "cannot have zero space on stack");
  65         fBuffer[0] = 0;
  66     }
  67
  68     CompactUnicodeString(const UnicodeString& text)
  69             : fBuffer(text.length() + 1) {
  70         uprv_memcpy(fBuffer.getAlias(), text.getBuffer(), sizeof(UChar) * text.length());
  71         fBuffer[text.length()] = 0;
  72     }
  73
  74     inline UnicodeString toAliasedUnicodeString() const {
  75         return UnicodeString(TRUE, fBuffer.getAlias(), -1);
  76     }
  77
  78     bool operator==(const CompactUnicodeString& other) const {
  79         // Use the alias-only constructor and then call UnicodeString operator==
  80         return toAliasedUnicodeString() == other.toAliasedUnicodeString();
  81     }
  82
  83   private:
  84     MaybeStackArray<UChar, stackCapacity> fBuffer;
  85 };
  86
  87
  88 /**
  89  * Struct-like class to hold the results of a parsing routine.
  90  *
  91  * @author sffc
  92  */
  93 // Exported as U_I18N_API for tests
  94 class U_I18N_API ParsedNumber {
  95   public:
  96
  97     /**
  98      * The numerical value that was parsed.
  99      */
 100     ::icu::number::impl::DecimalQuantity quantity;
 101
 102     /**
 103      * The index of the last char consumed during parsing. If parsing started at index 0, this is equal
 104      * to the number of chars consumed. This is NOT necessarily the same as the StringSegment offset;
 105      * "weak" chars, like whitespace, change the offset, but the charsConsumed is not touched until a
 106      * "strong" char is encountered.
 107      */
 108     int32_t charEnd;
 109
 110     /**
 111      * Boolean flags (see constants above).
 112      */
 113     result_flags_t flags;
 114
 115     /**
 116      * The pattern string corresponding to the prefix that got consumed.
 117      */
 118     UnicodeString prefix;
 119
 120     /**
 121      * The pattern string corresponding to the suffix that got consumed.
 122      */
 123     UnicodeString suffix;
 124
 125     /**
 126      * The currency that got consumed.
 127      */
 128     UChar currencyCode[4];
 129
 130     ParsedNumber();
 131
 132     ParsedNumber(const ParsedNumber& other) = default;
 133
 134     ParsedNumber& operator=(const ParsedNumber& other) = default;
 135
 136     void clear();
 137
 138     /**
 139      * Call this method to register that a "strong" char was consumed. This should be done after calling
 140      * {@link StringSegment#setOffset} or {@link StringSegment#adjustOffset} except when the char is
 141      * "weak", like whitespace.
 142      *
 143      * <p>
 144      * <strong>What is a strong versus weak char?</strong> The behavior of number parsing is to "stop"
 145      * after reading the number, even if there is other content following the number. For example, after
 146      * parsing the string "123 " (123 followed by a space), the cursor should be set to 3, not 4, even
 147      * though there are matchers that accept whitespace. In this example, the digits are strong, whereas
 148      * the whitespace is weak. Grouping separators are weak, whereas decimal separators are strong. Most
 149      * other chars are strong.
 150      *
 151      * @param segment
 152      *            The current StringSegment, usually immediately following a call to setOffset.
 153      */
 154     void setCharsConsumed(const StringSegment& segment);
 155
 156     /** Apply certain number-related flags to the DecimalQuantity. */
 157     void postProcess();
 158
 159     /**
 160      * Returns whether this the parse was successful. To be successful, at least one char must have been
 161      * consumed, and the failure flag must not be set.
 162      */
 163     bool success() const;
 164
 165     bool seenNumber() const;
 166
 167     double getDouble(UErrorCode& status) const;
 168
 169     void populateFormattable(Formattable& output, parse_flags_t parseFlags) const;
 170
 171     bool isBetterThan(const ParsedNumber& other);
 172 };
 173
 174
 175 /**
 176  * The core interface implemented by all matchers used for number parsing.
 177  *
 178  * Given a string, there should NOT be more than one way to consume the string with the same matcher
 179  * applied multiple times. If there is, the non-greedy parsing algorithm will be unhappy and may enter an
 180  * exponential-time loop. For example, consider the "A Matcher" that accepts "any number of As". Given
 181  * the string "AAAA", there are 2^N = 8 ways to apply the A Matcher to this string: you could have the A
 182  * Matcher apply 4 times to each character; you could have it apply just once to all the characters; you
 183  * could have it apply to the first 2 characters and the second 2 characters; and so on. A better version
 184  * of the "A Matcher" would be for it to accept exactly one A, and allow the algorithm to run it
 185  * repeatedly to consume a string of multiple As. The A Matcher can implement the Flexible interface
 186  * below to signal that it can be applied multiple times in a row.
 187  *
 188  * @author sffc
 189  */
 190 // Exported as U_I18N_API for tests
 191 class U_I18N_API NumberParseMatcher {
 192   public:
 193     virtual ~NumberParseMatcher();
 194
 195     /**
 196      * Matchers can override this method to return true to indicate that they are optional and can be run
 197      * repeatedly. Used by SeriesMatcher, primarily in the context of IgnorablesMatcher.
 198      */
 199     virtual bool isFlexible() const {
 200         return false;
 201     }
 202
 203     /**
 204      * Runs this matcher starting at the beginning of the given StringSegment. If this matcher finds
 205      * something interesting in the StringSegment, it should update the offset of the StringSegment
 206      * corresponding to how many chars were matched.
 207      *
 208      * This method is thread-safe.
 209      *
 210      * @param segment
 211      *            The StringSegment to match against. Matches always start at the beginning of the
 212      *            segment. The segment is guaranteed to contain at least one char.
 213      * @param result
 214      *            The data structure to store results if the match succeeds.
 215      * @return Whether this matcher thinks there may be more interesting chars beyond the end of the
 216      *         string segment.
 217      */
 218     virtual bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const = 0;
 219
 220     /**
 221      * Performs a fast "smoke check" for whether or not this matcher could possibly match against the
 222      * given string segment. The test should be as fast as possible but also as restrictive as possible.
 223      * For example, matchers can maintain a UnicodeSet of all code points that count possibly start a
 224      * match. Matchers should use the {@link StringSegment#startsWith} method in order to correctly
 225      * handle case folding.
 226      *
 227      * @param segment
 228      *            The segment to check against.
 229      * @return true if the matcher might be able to match against this segment; false if it definitely
 230      *         will not be able to match.
 231      */
 232     virtual bool smokeTest(const StringSegment& segment) const = 0;
 233
 234     /**
 235      * Method called at the end of a parse, after all matchers have failed to consume any more chars.
 236      * Allows a matcher to make final modifications to the result given the knowledge that no more
 237      * matches are possible.
 238      *
 239      * @param result
 240      *            The data structure to store results.
 241      */
 242     virtual void postProcess(ParsedNumber&) const {
 243         // Default implementation: no-op
 244     }
 245
 246     // String for debugging
 247     virtual UnicodeString toString() const = 0;
 248
 249   protected:
 250     // No construction except by subclasses!
 251     NumberParseMatcher() = default;
 252 };
 253
 254
 255 /**
 256  * Interface for use in arguments.
 257  */
 258 // Exported as U_I18N_API for tests
 259 class U_I18N_API MutableMatcherCollection {
 260   public:
 261     virtual ~MutableMatcherCollection() = default;
 262
 263     virtual void addMatcher(NumberParseMatcher& matcher) = 0;
 264 };
 265
 266
 267 } // namespace impl
 268 } // namespace numparse
 269 U_NAMESPACE_END
 270
 271 #endif //__NUMPARSE_TYPES_H__
 272 #endif /* #if !UCONFIG_NO_FORMATTING */