icuSources/i18n/numparse_compositions.cpp

   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
   8 // Allow implicit conversion from char16_t* to UnicodeString for this file:
   9 // Helpful in toString methods and elsewhere.
  10 #define UNISTR_FROM_STRING_EXPLICIT
  11
  12 #include "numparse_types.h"
  13 #include "numparse_compositions.h"
  14 #include "unicode/uniset.h"
  15
  16 using namespace icu;
  17 using namespace icu::numparse;
  18 using namespace icu::numparse::impl;
  19
  20
  21 bool SeriesMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
  22     ParsedNumber backup(result);
  23
  24     int32_t initialOffset = segment.getOffset();
  25     bool maybeMore = true;
  26     for (auto* it = begin(); it < end();) {
  27         const NumberParseMatcher* matcher = *it;
  28         int matcherOffset = segment.getOffset();
  29         if (segment.length() != 0) {
  30             maybeMore = matcher->match(segment, result, status);
  31         } else {
  32             // Nothing for this matcher to match; ask for more.
  33             maybeMore = true;
  34         }
  35
  36         bool success = (segment.getOffset() != matcherOffset);
  37         bool isFlexible = matcher->isFlexible();
  38         if (success && isFlexible) {
  39             // Match succeeded, and this is a flexible matcher. Re-run it.
  40         } else if (success) {
  41             // Match succeeded, and this is NOT a flexible matcher. Proceed to the next matcher.
  42             it++;
  43             // Small hack: if there is another matcher coming, do not accept trailing weak chars.
  44             // Needed for proper handling of currency spacing.
  45             if (it < end() && segment.getOffset() != result.charEnd && result.charEnd > matcherOffset) {
  46                 segment.setOffset(result.charEnd);
  47             }
  48         } else if (isFlexible) {
  49             // Match failed, and this is a flexible matcher. Try again with the next matcher.
  50             it++;
  51         } else {
  52             // Match failed, and this is NOT a flexible matcher. Exit.
  53             segment.setOffset(initialOffset);
  54             result = backup;
  55             return maybeMore;
  56         }
  57     }
  58
  59     // All matchers in the series succeeded.
  60     return maybeMore;
  61 }
  62
  63 bool SeriesMatcher::smokeTest(const StringSegment& segment) const {
  64     // NOTE: The range-based for loop calls the virtual begin() and end() methods.
  65     // NOTE: We only want the first element. Use the for loop for boundary checking.
  66     for (auto& matcher : *this) {
  67         // SeriesMatchers are never allowed to start with a Flexible matcher.
  68         U_ASSERT(!matcher->isFlexible());
  69         return matcher->smokeTest(segment);
  70     }
  71     return false;
  72 }
  73
  74 void SeriesMatcher::postProcess(ParsedNumber& result) const {
  75     // NOTE: The range-based for loop calls the virtual begin() and end() methods.
  76     for (auto* matcher : *this) {
  77         matcher->postProcess(result);
  78     }
  79 }
  80
  81
  82 ArraySeriesMatcher::ArraySeriesMatcher()
  83         : fMatchersLen(0) {
  84 }
  85
  86 ArraySeriesMatcher::ArraySeriesMatcher(MatcherArray& matchers, int32_t matchersLen)
  87         : fMatchers(std::move(matchers)), fMatchersLen(matchersLen) {
  88 }
  89
  90 int32_t ArraySeriesMatcher::length() const {
  91     return fMatchersLen;
  92 }
  93
  94 const NumberParseMatcher* const* ArraySeriesMatcher::begin() const {
  95     return fMatchers.getAlias();
  96 }
  97
  98 const NumberParseMatcher* const* ArraySeriesMatcher::end() const {
  99     return fMatchers.getAlias() + fMatchersLen;
 100 }
 101
 102 UnicodeString ArraySeriesMatcher::toString() const {
 103     return u"<ArraySeries>";
 104 }
 105
 106
 107 #endif /* #if !UCONFIG_NO_FORMATTING */