summaryrefslogtreecommitdiffstats
path: root/intl/icu/source/i18n/measunit_extra.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'intl/icu/source/i18n/measunit_extra.cpp')
-rw-r--r--intl/icu/source/i18n/measunit_extra.cpp1260
1 files changed, 1260 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/measunit_extra.cpp b/intl/icu/source/i18n/measunit_extra.cpp
new file mode 100644
index 0000000000..295d6a8ce8
--- /dev/null
+++ b/intl/icu/source/i18n/measunit_extra.cpp
@@ -0,0 +1,1260 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+// Extra functions for MeasureUnit not needed for all clients.
+// Separate .o file so that it can be removed for modularity.
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "charstr.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "measunit_impl.h"
+#include "resource.h"
+#include "uarrsort.h"
+#include "uassert.h"
+#include "ucln_in.h"
+#include "umutex.h"
+#include "unicode/bytestrie.h"
+#include "unicode/bytestriebuilder.h"
+#include "unicode/localpointer.h"
+#include "unicode/stringpiece.h"
+#include "unicode/stringtriebuilder.h"
+#include "unicode/ures.h"
+#include "unicode/ustringtrie.h"
+#include "uresimp.h"
+#include "util.h"
+#include <cstdlib>
+
+U_NAMESPACE_BEGIN
+
+
+namespace {
+
+// TODO: Propose a new error code for this?
+constexpr UErrorCode kUnitIdentifierSyntaxError = U_ILLEGAL_ARGUMENT_ERROR;
+
+// Trie value offset for SI or binary prefixes. This is big enough to ensure we only
+// insert positive integers into the trie.
+constexpr int32_t kPrefixOffset = 64;
+static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_BIN > 0,
+ "kPrefixOffset is too small for minimum UMeasurePrefix value");
+static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_SI > 0,
+ "kPrefixOffset is too small for minimum UMeasurePrefix value");
+
+// Trie value offset for compound parts, e.g. "-per-", "-", "-and-".
+constexpr int32_t kCompoundPartOffset = 128;
+static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_BIN,
+ "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");
+static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_SI,
+ "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");
+
+enum CompoundPart {
+ // Represents "-per-"
+ COMPOUND_PART_PER = kCompoundPartOffset,
+ // Represents "-"
+ COMPOUND_PART_TIMES,
+ // Represents "-and-"
+ COMPOUND_PART_AND,
+};
+
+// Trie value offset for "per-".
+constexpr int32_t kInitialCompoundPartOffset = 192;
+
+enum InitialCompoundPart {
+ // Represents "per-", the only compound part that can appear at the start of
+ // an identifier.
+ INITIAL_COMPOUND_PART_PER = kInitialCompoundPartOffset,
+};
+
+// Trie value offset for powers like "square-", "cubic-", "pow2-" etc.
+constexpr int32_t kPowerPartOffset = 256;
+
+enum PowerPart {
+ POWER_PART_P2 = kPowerPartOffset + 2,
+ POWER_PART_P3,
+ POWER_PART_P4,
+ POWER_PART_P5,
+ POWER_PART_P6,
+ POWER_PART_P7,
+ POWER_PART_P8,
+ POWER_PART_P9,
+ POWER_PART_P10,
+ POWER_PART_P11,
+ POWER_PART_P12,
+ POWER_PART_P13,
+ POWER_PART_P14,
+ POWER_PART_P15,
+};
+
+// Trie value offset for simple units, e.g. "gram", "nautical-mile",
+// "fluid-ounce-imperial".
+constexpr int32_t kSimpleUnitOffset = 512;
+
+const struct UnitPrefixStrings {
+ const char* const string;
+ UMeasurePrefix value;
+} gUnitPrefixStrings[] = {
+ // SI prefixes
+ { "yotta", UMEASURE_PREFIX_YOTTA },
+ { "zetta", UMEASURE_PREFIX_ZETTA },
+ { "exa", UMEASURE_PREFIX_EXA },
+ { "peta", UMEASURE_PREFIX_PETA },
+ { "tera", UMEASURE_PREFIX_TERA },
+ { "giga", UMEASURE_PREFIX_GIGA },
+ { "mega", UMEASURE_PREFIX_MEGA },
+ { "kilo", UMEASURE_PREFIX_KILO },
+ { "hecto", UMEASURE_PREFIX_HECTO },
+ { "deka", UMEASURE_PREFIX_DEKA },
+ { "deci", UMEASURE_PREFIX_DECI },
+ { "centi", UMEASURE_PREFIX_CENTI },
+ { "milli", UMEASURE_PREFIX_MILLI },
+ { "micro", UMEASURE_PREFIX_MICRO },
+ { "nano", UMEASURE_PREFIX_NANO },
+ { "pico", UMEASURE_PREFIX_PICO },
+ { "femto", UMEASURE_PREFIX_FEMTO },
+ { "atto", UMEASURE_PREFIX_ATTO },
+ { "zepto", UMEASURE_PREFIX_ZEPTO },
+ { "yocto", UMEASURE_PREFIX_YOCTO },
+ // Binary prefixes
+ { "yobi", UMEASURE_PREFIX_YOBI },
+ { "zebi", UMEASURE_PREFIX_ZEBI },
+ { "exbi", UMEASURE_PREFIX_EXBI },
+ { "pebi", UMEASURE_PREFIX_PEBI },
+ { "tebi", UMEASURE_PREFIX_TEBI },
+ { "gibi", UMEASURE_PREFIX_GIBI },
+ { "mebi", UMEASURE_PREFIX_MEBI },
+ { "kibi", UMEASURE_PREFIX_KIBI },
+};
+
+/**
+ * A ResourceSink that collects simple unit identifiers from the keys of the
+ * convertUnits table into an array, and adds these values to a TrieBuilder,
+ * with associated values being their index into this array plus a specified
+ * offset.
+ *
+ * Example code:
+ *
+ * UErrorCode status = U_ZERO_ERROR;
+ * BytesTrieBuilder b(status);
+ * int32_t ARR_SIZE = 200;
+ * const char *unitIdentifiers[ARR_SIZE];
+ * int32_t *unitCategories[ARR_SIZE];
+ * SimpleUnitIdentifiersSink identifierSink(gSerializedUnitCategoriesTrie, unitIdentifiers,
+ * unitCategories, ARR_SIZE, b, kTrieValueOffset);
+ * LocalUResourceBundlePointer unitsBundle(ures_openDirect(nullptr, "units", &status));
+ * ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);
+ */
+class SimpleUnitIdentifiersSink : public icu::ResourceSink {
+ public:
+ /**
+ * Constructor.
+ * @param quantitiesTrieData The data for constructing a quantitiesTrie,
+ * which maps from a simple unit identifier to an index into the
+ * gCategories array.
+ * @param out Array of char* to which pointers to the simple unit
+ * identifiers will be saved. (Does not take ownership.)
+ * @param outCategories Array of int32_t to which category indexes will be
+ * saved: this corresponds to simple unit IDs saved to `out`, mapping
+ * from the ID to the value produced by the quantitiesTrie (which is an
+ * index into the gCategories array).
+ * @param outSize The size of `out` and `outCategories`.
+ * @param trieBuilder The trie builder to which the simple unit identifier
+ * should be added. The trie builder must outlive this resource sink.
+ * @param trieValueOffset This is added to the index of the identifier in
+ * the `out` array, before adding to `trieBuilder` as the value
+ * associated with the identifier.
+ */
+ explicit SimpleUnitIdentifiersSink(StringPiece quantitiesTrieData, const char **out,
+ int32_t *outCategories, int32_t outSize,
+ BytesTrieBuilder &trieBuilder, int32_t trieValueOffset)
+ : outArray(out), outCategories(outCategories), outSize(outSize), trieBuilder(trieBuilder),
+ trieValueOffset(trieValueOffset), quantitiesTrieData(quantitiesTrieData), outIndex(0) {}
+
+ /**
+ * Adds the table keys found in value to the output vector.
+ * @param key The key of the resource passed to `value`: the second
+ * parameter of the ures_getAllItemsWithFallback() call.
+ * @param value Should be a ResourceTable value, if
+ * ures_getAllItemsWithFallback() was called correctly for this sink.
+ * @param noFallback Ignored.
+ * @param status The standard ICU error code output parameter.
+ */
+ void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
+ ResourceTable table = value.getTable(status);
+ if (U_FAILURE(status)) return;
+
+ if (outIndex + table.getSize() > outSize) {
+ status = U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+
+ BytesTrie quantitiesTrie(quantitiesTrieData.data());
+
+ // Collect keys from the table resource.
+ const char *simpleUnitID;
+ for (int32_t i = 0; table.getKeyAndValue(i, simpleUnitID, value); ++i) {
+ U_ASSERT(i < table.getSize());
+ U_ASSERT(outIndex < outSize);
+ if (uprv_strcmp(simpleUnitID, "kilogram") == 0) {
+ // For parsing, we use "gram", the prefixless metric mass unit. We
+ // thus ignore the SI Base Unit of Mass: it exists due to being the
+ // mass conversion target unit, but not needed for MeasureUnit
+ // parsing.
+ continue;
+ }
+ outArray[outIndex] = simpleUnitID;
+ trieBuilder.add(simpleUnitID, trieValueOffset + outIndex, status);
+
+ // Find the base target unit for this simple unit
+ ResourceTable table = value.getTable(status);
+ if (U_FAILURE(status)) { return; }
+ if (!table.findValue("target", value)) {
+ status = U_INVALID_FORMAT_ERROR;
+ break;
+ }
+ int32_t len;
+ const char16_t* uTarget = value.getString(len, status);
+ CharString target;
+ target.appendInvariantChars(uTarget, len, status);
+ if (U_FAILURE(status)) { return; }
+ quantitiesTrie.reset();
+ UStringTrieResult result = quantitiesTrie.next(target.data(), target.length());
+ if (!USTRINGTRIE_HAS_VALUE(result)) {
+ status = U_INVALID_FORMAT_ERROR;
+ break;
+ }
+ outCategories[outIndex] = quantitiesTrie.getValue();
+
+ outIndex++;
+ }
+ }
+
+ private:
+ const char **outArray;
+ int32_t *outCategories;
+ int32_t outSize;
+ BytesTrieBuilder &trieBuilder;
+ int32_t trieValueOffset;
+
+ StringPiece quantitiesTrieData;
+
+ int32_t outIndex;
+};
+
+/**
+ * A ResourceSink that collects information from `unitQuantities` in the `units`
+ * resource to provide key->value lookups from base unit to category, as well as
+ * preserving ordering information for these categories. See `units.txt`.
+ *
+ * For example: "kilogram" -> "mass", "meter-per-second" -> "speed".
+ *
+ * In C++ unitQuantity values are collected in order into a char16_t* array, while
+ * unitQuantity keys are added added to a TrieBuilder, with associated values
+ * being the index into the aforementioned char16_t* array.
+ */
+class CategoriesSink : public icu::ResourceSink {
+ public:
+ /**
+ * Constructor.
+ * @param out Array of char16_t* to which unitQuantity values will be saved.
+ * The pointers returned not owned: they point directly at the resource
+ * strings in static memory.
+ * @param outSize The size of the `out` array.
+ * @param trieBuilder The trie builder to which the keys (base units) of
+ * each unitQuantity will be added, each with value being the offset
+ * into `out`.
+ */
+ explicit CategoriesSink(const char16_t **out, int32_t &outSize, BytesTrieBuilder &trieBuilder)
+ : outQuantitiesArray(out), outSize(outSize), trieBuilder(trieBuilder), outIndex(0) {}
+
+ void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
+ ResourceArray array = value.getArray(status);
+ if (U_FAILURE(status)) {
+ return;
+ }
+
+ if (outIndex + array.getSize() > outSize) {
+ status = U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+
+ for (int32_t i = 0; array.getValue(i, value); ++i) {
+ U_ASSERT(outIndex < outSize);
+ ResourceTable table = value.getTable(status);
+ if (U_FAILURE(status)) {
+ return;
+ }
+ if (table.getSize() != 1) {
+ status = U_INVALID_FORMAT_ERROR;
+ return;
+ }
+ const char *key;
+ table.getKeyAndValue(0, key, value);
+ int32_t uTmpLen;
+ outQuantitiesArray[outIndex] = value.getString(uTmpLen, status);
+ trieBuilder.add(key, outIndex, status);
+ outIndex++;
+ }
+ }
+
+ private:
+ const char16_t **outQuantitiesArray;
+ int32_t &outSize;
+ BytesTrieBuilder &trieBuilder;
+
+ int32_t outIndex;
+};
+
+icu::UInitOnce gUnitExtrasInitOnce {};
+
+// Array of simple unit IDs.
+//
+// The array memory itself is owned by this pointer, but the individual char* in
+// that array point at static memory. (Note that these char* are also returned
+// by SingleUnitImpl::getSimpleUnitID().)
+const char **gSimpleUnits = nullptr;
+
+// Maps from the value associated with each simple unit ID to an index into the
+// gCategories array.
+int32_t *gSimpleUnitCategories = nullptr;
+
+char *gSerializedUnitExtrasStemTrie = nullptr;
+
+// Array of char16_t* pointing at the unit categories (aka "quantities", aka
+// "types"), as found in the `unitQuantities` resource. The array memory itself
+// is owned by this pointer, but the individual char16_t* in that array point at
+// static memory.
+const char16_t **gCategories = nullptr;
+// Number of items in `gCategories`.
+int32_t gCategoriesCount = 0;
+// Serialized BytesTrie for mapping from base units to indices into gCategories.
+char *gSerializedUnitCategoriesTrie = nullptr;
+
+UBool U_CALLCONV cleanupUnitExtras() {
+ uprv_free(gSerializedUnitCategoriesTrie);
+ gSerializedUnitCategoriesTrie = nullptr;
+ uprv_free(gCategories);
+ gCategories = nullptr;
+ uprv_free(gSerializedUnitExtrasStemTrie);
+ gSerializedUnitExtrasStemTrie = nullptr;
+ uprv_free(gSimpleUnitCategories);
+ gSimpleUnitCategories = nullptr;
+ uprv_free(gSimpleUnits);
+ gSimpleUnits = nullptr;
+ gUnitExtrasInitOnce.reset();
+ return true;
+}
+
+void U_CALLCONV initUnitExtras(UErrorCode& status) {
+ ucln_i18n_registerCleanup(UCLN_I18N_UNIT_EXTRAS, cleanupUnitExtras);
+ LocalUResourceBundlePointer unitsBundle(ures_openDirect(nullptr, "units", &status));
+
+ // Collect unitQuantities information into gSerializedUnitCategoriesTrie and gCategories.
+ const char *CATEGORY_TABLE_NAME = "unitQuantities";
+ LocalUResourceBundlePointer unitQuantities(
+ ures_getByKey(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, nullptr, &status));
+ if (U_FAILURE(status)) { return; }
+ gCategoriesCount = unitQuantities.getAlias()->fSize;
+ size_t quantitiesMallocSize = sizeof(char16_t *) * gCategoriesCount;
+ gCategories = static_cast<const char16_t **>(uprv_malloc(quantitiesMallocSize));
+ if (gCategories == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_memset(gCategories, 0, quantitiesMallocSize);
+ BytesTrieBuilder quantitiesBuilder(status);
+ CategoriesSink categoriesSink(gCategories, gCategoriesCount, quantitiesBuilder);
+ ures_getAllItemsWithFallback(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, categoriesSink, status);
+ StringPiece resultQuantities = quantitiesBuilder.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
+ if (U_FAILURE(status)) { return; }
+ // Copy the result into the global constant pointer
+ size_t numBytesQuantities = resultQuantities.length();
+ gSerializedUnitCategoriesTrie = static_cast<char *>(uprv_malloc(numBytesQuantities));
+ if (gSerializedUnitCategoriesTrie == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_memcpy(gSerializedUnitCategoriesTrie, resultQuantities.data(), numBytesQuantities);
+
+ // Build the BytesTrie that Parser needs for parsing unit identifiers.
+
+ BytesTrieBuilder b(status);
+ if (U_FAILURE(status)) { return; }
+
+ // Add SI and binary prefixes
+ for (const auto& unitPrefixInfo : gUnitPrefixStrings) {
+ b.add(unitPrefixInfo.string, unitPrefixInfo.value + kPrefixOffset, status);
+ }
+ if (U_FAILURE(status)) { return; }
+
+ // Add syntax parts (compound, power prefixes)
+ b.add("-per-", COMPOUND_PART_PER, status);
+ b.add("-", COMPOUND_PART_TIMES, status);
+ b.add("-and-", COMPOUND_PART_AND, status);
+ b.add("per-", INITIAL_COMPOUND_PART_PER, status);
+ b.add("square-", POWER_PART_P2, status);
+ b.add("cubic-", POWER_PART_P3, status);
+ b.add("pow2-", POWER_PART_P2, status);
+ b.add("pow3-", POWER_PART_P3, status);
+ b.add("pow4-", POWER_PART_P4, status);
+ b.add("pow5-", POWER_PART_P5, status);
+ b.add("pow6-", POWER_PART_P6, status);
+ b.add("pow7-", POWER_PART_P7, status);
+ b.add("pow8-", POWER_PART_P8, status);
+ b.add("pow9-", POWER_PART_P9, status);
+ b.add("pow10-", POWER_PART_P10, status);
+ b.add("pow11-", POWER_PART_P11, status);
+ b.add("pow12-", POWER_PART_P12, status);
+ b.add("pow13-", POWER_PART_P13, status);
+ b.add("pow14-", POWER_PART_P14, status);
+ b.add("pow15-", POWER_PART_P15, status);
+ if (U_FAILURE(status)) { return; }
+
+ // Add sanctioned simple units by offset: simple units all have entries in
+ // units/convertUnits resources.
+ LocalUResourceBundlePointer convertUnits(
+ ures_getByKey(unitsBundle.getAlias(), "convertUnits", nullptr, &status));
+ if (U_FAILURE(status)) { return; }
+
+ // Allocate enough space: with identifierSink below skipping kilogram, we're
+ // probably allocating one more than needed.
+ int32_t simpleUnitsCount = convertUnits.getAlias()->fSize;
+ int32_t arrayMallocSize = sizeof(char *) * simpleUnitsCount;
+ gSimpleUnits = static_cast<const char **>(uprv_malloc(arrayMallocSize));
+ if (gSimpleUnits == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_memset(gSimpleUnits, 0, arrayMallocSize);
+ arrayMallocSize = sizeof(int32_t) * simpleUnitsCount;
+ gSimpleUnitCategories = static_cast<int32_t *>(uprv_malloc(arrayMallocSize));
+ if (gSimpleUnitCategories == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_memset(gSimpleUnitCategories, 0, arrayMallocSize);
+
+ // Populate gSimpleUnits and build the associated trie.
+ SimpleUnitIdentifiersSink identifierSink(resultQuantities, gSimpleUnits, gSimpleUnitCategories,
+ simpleUnitsCount, b, kSimpleUnitOffset);
+ ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);
+
+ // Build the CharsTrie
+ // TODO: Use SLOW or FAST here?
+ StringPiece result = b.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
+ if (U_FAILURE(status)) { return; }
+
+ // Copy the result into the global constant pointer
+ size_t numBytes = result.length();
+ gSerializedUnitExtrasStemTrie = static_cast<char *>(uprv_malloc(numBytes));
+ if (gSerializedUnitExtrasStemTrie == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ uprv_memcpy(gSerializedUnitExtrasStemTrie, result.data(), numBytes);
+}
+
+class Token {
+public:
+ Token(int32_t match) : fMatch(match) {}
+
+ enum Type {
+ TYPE_UNDEFINED,
+ TYPE_PREFIX,
+ // Token type for "-per-", "-", and "-and-".
+ TYPE_COMPOUND_PART,
+ // Token type for "per-".
+ TYPE_INITIAL_COMPOUND_PART,
+ TYPE_POWER_PART,
+ TYPE_SIMPLE_UNIT,
+ };
+
+ // Calling getType() is invalid, resulting in an assertion failure, if Token
+ // value isn't positive.
+ Type getType() const {
+ U_ASSERT(fMatch > 0);
+ if (fMatch < kCompoundPartOffset) {
+ return TYPE_PREFIX;
+ }
+ if (fMatch < kInitialCompoundPartOffset) {
+ return TYPE_COMPOUND_PART;
+ }
+ if (fMatch < kPowerPartOffset) {
+ return TYPE_INITIAL_COMPOUND_PART;
+ }
+ if (fMatch < kSimpleUnitOffset) {
+ return TYPE_POWER_PART;
+ }
+ return TYPE_SIMPLE_UNIT;
+ }
+
+ UMeasurePrefix getUnitPrefix() const {
+ U_ASSERT(getType() == TYPE_PREFIX);
+ return static_cast<UMeasurePrefix>(fMatch - kPrefixOffset);
+ }
+
+ // Valid only for tokens with type TYPE_COMPOUND_PART.
+ int32_t getMatch() const {
+ U_ASSERT(getType() == TYPE_COMPOUND_PART);
+ return fMatch;
+ }
+
+ int32_t getInitialCompoundPart() const {
+ // Even if there is only one InitialCompoundPart value, we have this
+ // function for the simplicity of code consistency.
+ U_ASSERT(getType() == TYPE_INITIAL_COMPOUND_PART);
+ // Defensive: if this assert fails, code using this function also needs
+ // to change.
+ U_ASSERT(fMatch == INITIAL_COMPOUND_PART_PER);
+ return fMatch;
+ }
+
+ int8_t getPower() const {
+ U_ASSERT(getType() == TYPE_POWER_PART);
+ return static_cast<int8_t>(fMatch - kPowerPartOffset);
+ }
+
+ int32_t getSimpleUnitIndex() const {
+ U_ASSERT(getType() == TYPE_SIMPLE_UNIT);
+ return fMatch - kSimpleUnitOffset;
+ }
+
+private:
+ int32_t fMatch;
+};
+
+class Parser {
+public:
+ /**
+ * Factory function for parsing the given identifier.
+ *
+ * @param source The identifier to parse. This function does not make a copy
+ * of source: the underlying string that source points at, must outlive the
+ * parser.
+ * @param status ICU error code.
+ */
+ static Parser from(StringPiece source, UErrorCode& status) {
+ if (U_FAILURE(status)) {
+ return Parser();
+ }
+ umtx_initOnce(gUnitExtrasInitOnce, &initUnitExtras, status);
+ if (U_FAILURE(status)) {
+ return Parser();
+ }
+ return Parser(source);
+ }
+
+ MeasureUnitImpl parse(UErrorCode& status) {
+ MeasureUnitImpl result;
+
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ if (fSource.empty()) {
+ // The dimenionless unit: nothing to parse. leave result as is.
+ return result;
+ }
+
+ while (hasNext()) {
+ bool sawAnd = false;
+
+ SingleUnitImpl singleUnit = nextSingleUnit(sawAnd, status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+
+ bool added = result.appendSingleUnit(singleUnit, status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+
+ if (sawAnd && !added) {
+ // Two similar units are not allowed in a mixed unit.
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+
+ if (result.singleUnits.length() >= 2) {
+ // nextSingleUnit fails appropriately for "per" and "and" in the
+ // same identifier. It doesn't fail for other compound units
+ // (COMPOUND_PART_TIMES). Consequently we take care of that
+ // here.
+ UMeasureUnitComplexity complexity =
+ sawAnd ? UMEASURE_UNIT_MIXED : UMEASURE_UNIT_COMPOUND;
+ if (result.singleUnits.length() == 2) {
+ // After appending two singleUnits, the complexity will be `UMEASURE_UNIT_COMPOUND`
+ U_ASSERT(result.complexity == UMEASURE_UNIT_COMPOUND);
+ result.complexity = complexity;
+ } else if (result.complexity != complexity) {
+ // Can't have mixed compound units
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ }
+ }
+
+ return result;
+ }
+
+private:
+ // Tracks parser progress: the offset into fSource.
+ int32_t fIndex = 0;
+
+ // Since we're not owning this memory, whatever is passed to the constructor
+ // should live longer than this Parser - and the parser shouldn't return any
+ // references to that string.
+ StringPiece fSource;
+ BytesTrie fTrie;
+
+ // Set to true when we've seen a "-per-" or a "per-", after which all units
+ // are in the denominator. Until we find an "-and-", at which point the
+ // identifier is invalid pending TODO(CLDR-13701).
+ bool fAfterPer = false;
+
+ Parser() : fSource(""), fTrie(u"") {}
+
+ Parser(StringPiece source)
+ : fSource(source), fTrie(gSerializedUnitExtrasStemTrie) {}
+
+ inline bool hasNext() const {
+ return fIndex < fSource.length();
+ }
+
+ // Returns the next Token parsed from fSource, advancing fIndex to the end
+ // of that token in fSource. In case of U_FAILURE(status), the token
+ // returned will cause an abort if getType() is called on it.
+ Token nextToken(UErrorCode& status) {
+ fTrie.reset();
+ int32_t match = -1;
+ // Saves the position in the fSource string for the end of the most
+ // recent matching token.
+ int32_t previ = -1;
+ // Find the longest token that matches a value in the trie:
+ while (fIndex < fSource.length()) {
+ auto result = fTrie.next(fSource.data()[fIndex++]);
+ if (result == USTRINGTRIE_NO_MATCH) {
+ break;
+ } else if (result == USTRINGTRIE_NO_VALUE) {
+ continue;
+ }
+ U_ASSERT(USTRINGTRIE_HAS_VALUE(result));
+ match = fTrie.getValue();
+ previ = fIndex;
+ if (result == USTRINGTRIE_FINAL_VALUE) {
+ break;
+ }
+ U_ASSERT(result == USTRINGTRIE_INTERMEDIATE_VALUE);
+ // continue;
+ }
+
+ if (match < 0) {
+ status = kUnitIdentifierSyntaxError;
+ } else {
+ fIndex = previ;
+ }
+ return Token(match);
+ }
+
+ /**
+ * Returns the next "single unit" via result.
+ *
+ * If a "-per-" was parsed, the result will have appropriate negative
+ * dimensionality.
+ *
+ * Returns an error if we parse both compound units and "-and-", since mixed
+ * compound units are not yet supported - TODO(CLDR-13701).
+ *
+ * @param result Will be overwritten by the result, if status shows success.
+ * @param sawAnd If an "-and-" was parsed prior to finding the "single
+ * unit", sawAnd is set to true. If not, it is left as is.
+ * @param status ICU error code.
+ */
+ SingleUnitImpl nextSingleUnit(bool &sawAnd, UErrorCode &status) {
+ SingleUnitImpl result;
+ if (U_FAILURE(status)) {
+ return result;
+ }
+
+ // state:
+ // 0 = no tokens seen yet (will accept power, SI or binary prefix, or simple unit)
+ // 1 = power token seen (will not accept another power token)
+ // 2 = SI or binary prefix token seen (will not accept a power, or SI or binary prefix token)
+ int32_t state = 0;
+
+ bool atStart = fIndex == 0;
+ Token token = nextToken(status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+
+ if (atStart) {
+ // Identifiers optionally start with "per-".
+ if (token.getType() == Token::TYPE_INITIAL_COMPOUND_PART) {
+ U_ASSERT(token.getInitialCompoundPart() == INITIAL_COMPOUND_PART_PER);
+ fAfterPer = true;
+ result.dimensionality = -1;
+
+ token = nextToken(status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+ } else {
+ // All other SingleUnit's are separated from previous SingleUnit's
+ // via a compound part:
+ if (token.getType() != Token::TYPE_COMPOUND_PART) {
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+
+ switch (token.getMatch()) {
+ case COMPOUND_PART_PER:
+ if (sawAnd) {
+ // Mixed compound units not yet supported,
+ // TODO(CLDR-13701).
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ fAfterPer = true;
+ result.dimensionality = -1;
+ break;
+
+ case COMPOUND_PART_TIMES:
+ if (fAfterPer) {
+ result.dimensionality = -1;
+ }
+ break;
+
+ case COMPOUND_PART_AND:
+ if (fAfterPer) {
+ // Can't start with "-and-", and mixed compound units
+ // not yet supported, TODO(CLDR-13701).
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ sawAnd = true;
+ break;
+ }
+
+ token = nextToken(status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ // Read tokens until we have a complete SingleUnit or we reach the end.
+ while (true) {
+ switch (token.getType()) {
+ case Token::TYPE_POWER_PART:
+ if (state > 0) {
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ result.dimensionality *= token.getPower();
+ state = 1;
+ break;
+
+ case Token::TYPE_PREFIX:
+ if (state > 1) {
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ result.unitPrefix = token.getUnitPrefix();
+ state = 2;
+ break;
+
+ case Token::TYPE_SIMPLE_UNIT:
+ result.index = token.getSimpleUnitIndex();
+ return result;
+
+ default:
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+
+ if (!hasNext()) {
+ // We ran out of tokens before finding a complete single unit.
+ status = kUnitIdentifierSyntaxError;
+ return result;
+ }
+ token = nextToken(status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ return result;
+ }
+};
+
+// Sorting function wrapping SingleUnitImpl::compareTo for use with uprv_sortArray.
+int32_t U_CALLCONV
+compareSingleUnits(const void* /*context*/, const void* left, const void* right) {
+ auto realLeft = static_cast<const SingleUnitImpl* const*>(left);
+ auto realRight = static_cast<const SingleUnitImpl* const*>(right);
+ return (*realLeft)->compareTo(**realRight);
+}
+
+// Returns an index into the gCategories array, for the "unitQuantity" (aka
+// "type" or "category") associated with the given base unit identifier. Returns
+// -1 on failure, together with U_UNSUPPORTED_ERROR.
+int32_t getUnitCategoryIndex(BytesTrie &trie, StringPiece baseUnitIdentifier, UErrorCode &status) {
+ UStringTrieResult result = trie.reset().next(baseUnitIdentifier.data(), baseUnitIdentifier.length());
+ if (!USTRINGTRIE_HAS_VALUE(result)) {
+ status = U_UNSUPPORTED_ERROR;
+ return -1;
+ }
+
+ return trie.getValue();
+}
+
+} // namespace
+
+U_CAPI int32_t U_EXPORT2
+umeas_getPrefixPower(UMeasurePrefix unitPrefix) {
+ if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
+ unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
+ return unitPrefix - UMEASURE_PREFIX_INTERNAL_ONE_BIN;
+ }
+ U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&
+ unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI);
+ return unitPrefix - UMEASURE_PREFIX_ONE;
+}
+
+U_CAPI int32_t U_EXPORT2
+umeas_getPrefixBase(UMeasurePrefix unitPrefix) {
+ if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
+ unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
+ return 1024;
+ }
+ U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&
+ unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI);
+ return 10;
+}
+
+CharString U_I18N_API getUnitQuantity(const MeasureUnitImpl &baseMeasureUnitImpl, UErrorCode &status) {
+ CharString result;
+ MeasureUnitImpl baseUnitImpl = baseMeasureUnitImpl.copy(status);
+ UErrorCode localStatus = U_ZERO_ERROR;
+ umtx_initOnce(gUnitExtrasInitOnce, &initUnitExtras, status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ BytesTrie trie(gSerializedUnitCategoriesTrie);
+
+ baseUnitImpl.serialize(status);
+ StringPiece identifier = baseUnitImpl.identifier.data();
+ int32_t idx = getUnitCategoryIndex(trie, identifier, localStatus);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+
+ // In case the base unit identifier did not match any entry.
+ if (U_FAILURE(localStatus)) {
+ localStatus = U_ZERO_ERROR;
+ baseUnitImpl.takeReciprocal(status);
+ baseUnitImpl.serialize(status);
+ identifier.set(baseUnitImpl.identifier.data());
+ idx = getUnitCategoryIndex(trie, identifier, localStatus);
+
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ // In case the reciprocal of the base unit identifier did not match any entry.
+ MeasureUnitImpl simplifiedUnit = baseMeasureUnitImpl.copyAndSimplify(status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ if (U_FAILURE(localStatus)) {
+ localStatus = U_ZERO_ERROR;
+ simplifiedUnit.serialize(status);
+ identifier.set(simplifiedUnit.identifier.data());
+ idx = getUnitCategoryIndex(trie, identifier, localStatus);
+
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ // In case the simplified base unit identifier did not match any entry.
+ if (U_FAILURE(localStatus)) {
+ localStatus = U_ZERO_ERROR;
+ simplifiedUnit.takeReciprocal(status);
+ simplifiedUnit.serialize(status);
+ identifier.set(simplifiedUnit.identifier.data());
+ idx = getUnitCategoryIndex(trie, identifier, localStatus);
+
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ // If there is no match at all, throw an exception.
+ if (U_FAILURE(localStatus)) {
+ status = U_INVALID_FORMAT_ERROR;
+ return result;
+ }
+
+ if (idx < 0 || idx >= gCategoriesCount) {
+ status = U_INVALID_FORMAT_ERROR;
+ return result;
+ }
+
+ result.appendInvariantChars(gCategories[idx], u_strlen(gCategories[idx]), status);
+ return result;
+}
+
+// In ICU4J, this is MeasureUnit.getSingleUnitImpl().
+SingleUnitImpl SingleUnitImpl::forMeasureUnit(const MeasureUnit& measureUnit, UErrorCode& status) {
+ MeasureUnitImpl temp;
+ const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(measureUnit, temp, status);
+ if (U_FAILURE(status)) {
+ return {};
+ }
+ if (impl.singleUnits.length() == 0) {
+ return {};
+ }
+ if (impl.singleUnits.length() == 1) {
+ return *impl.singleUnits[0];
+ }
+ status = U_ILLEGAL_ARGUMENT_ERROR;
+ return {};
+}
+
+MeasureUnit SingleUnitImpl::build(UErrorCode& status) const {
+ MeasureUnitImpl temp;
+ temp.appendSingleUnit(*this, status);
+ // TODO(icu-units#28): the MeasureUnitImpl::build() method uses
+ // findBySubtype, which is relatively slow.
+ // - At the time of loading the simple unit IDs, we could also save a
+ // mapping to the builtin MeasureUnit type and subtype they correspond to.
+ // - This method could then check dimensionality and index, and if both are
+ // 1, directly return MeasureUnit instances very quickly.
+ return std::move(temp).build(status);
+}
+
+const char *SingleUnitImpl::getSimpleUnitID() const {
+ return gSimpleUnits[index];
+}
+
+void SingleUnitImpl::appendNeutralIdentifier(CharString &result, UErrorCode &status) const UPRV_NO_SANITIZE_UNDEFINED {
+ int32_t absPower = std::abs(this->dimensionality);
+
+ U_ASSERT(absPower > 0); // "this function does not support the dimensionless single units";
+
+ if (absPower == 1) {
+ // no-op
+ } else if (absPower == 2) {
+ result.append(StringPiece("square-"), status);
+ } else if (absPower == 3) {
+ result.append(StringPiece("cubic-"), status);
+ } else if (absPower <= 15) {
+ result.append(StringPiece("pow"), status);
+ result.appendNumber(absPower, status);
+ result.append(StringPiece("-"), status);
+ } else {
+ status = U_ILLEGAL_ARGUMENT_ERROR; // Unit Identifier Syntax Error
+ return;
+ }
+
+ if (U_FAILURE(status)) {
+ return;
+ }
+
+ if (this->unitPrefix != UMEASURE_PREFIX_ONE) {
+ bool found = false;
+ for (const auto &unitPrefixInfo : gUnitPrefixStrings) {
+ // TODO: consider using binary search? If we do this, add a unit
+ // test to ensure gUnitPrefixStrings is sorted?
+ if (unitPrefixInfo.value == this->unitPrefix) {
+ result.append(unitPrefixInfo.string, status);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ status = U_UNSUPPORTED_ERROR;
+ return;
+ }
+ }
+
+ result.append(StringPiece(this->getSimpleUnitID()), status);
+}
+
+int32_t SingleUnitImpl::getUnitCategoryIndex() const {
+ return gSimpleUnitCategories[index];
+}
+
+MeasureUnitImpl::MeasureUnitImpl(const SingleUnitImpl &singleUnit, UErrorCode &status) {
+ this->appendSingleUnit(singleUnit, status);
+}
+
+MeasureUnitImpl MeasureUnitImpl::forIdentifier(StringPiece identifier, UErrorCode& status) {
+ return Parser::from(identifier, status).parse(status);
+}
+
+const MeasureUnitImpl& MeasureUnitImpl::forMeasureUnit(
+ const MeasureUnit& measureUnit, MeasureUnitImpl& memory, UErrorCode& status) {
+ if (measureUnit.fImpl) {
+ return *measureUnit.fImpl;
+ } else {
+ memory = Parser::from(measureUnit.getIdentifier(), status).parse(status);
+ return memory;
+ }
+}
+
+MeasureUnitImpl MeasureUnitImpl::forMeasureUnitMaybeCopy(
+ const MeasureUnit& measureUnit, UErrorCode& status) {
+ if (measureUnit.fImpl) {
+ return measureUnit.fImpl->copy(status);
+ } else {
+ return Parser::from(measureUnit.getIdentifier(), status).parse(status);
+ }
+}
+
+void MeasureUnitImpl::takeReciprocal(UErrorCode& /*status*/) {
+ identifier.clear();
+ for (int32_t i = 0; i < singleUnits.length(); i++) {
+ singleUnits[i]->dimensionality *= -1;
+ }
+}
+
+MeasureUnitImpl MeasureUnitImpl::copyAndSimplify(UErrorCode &status) const {
+ MeasureUnitImpl result;
+ for (int32_t i = 0; i < singleUnits.length(); i++) {
+ const SingleUnitImpl &singleUnit = *this->singleUnits[i];
+
+ // The following `for` loop will cause time complexity to be O(n^2).
+ // However, n is very small (number of units, generally, at maximum equal to 10)
+ bool unitExist = false;
+ for (int32_t j = 0; j < result.singleUnits.length(); j++) {
+ if (uprv_strcmp(result.singleUnits[j]->getSimpleUnitID(), singleUnit.getSimpleUnitID()) ==
+ 0 &&
+ result.singleUnits[j]->unitPrefix == singleUnit.unitPrefix) {
+ unitExist = true;
+ result.singleUnits[j]->dimensionality =
+ result.singleUnits[j]->dimensionality + singleUnit.dimensionality;
+ break;
+ }
+ }
+
+ if (!unitExist) {
+ result.appendSingleUnit(singleUnit, status);
+ }
+ }
+
+ return result;
+}
+
+bool MeasureUnitImpl::appendSingleUnit(const SingleUnitImpl &singleUnit, UErrorCode &status) {
+ identifier.clear();
+
+ if (singleUnit.isDimensionless()) {
+ // Do not append dimensionless units.
+ return false;
+ }
+
+ // Find a similar unit that already exists, to attempt to coalesce
+ SingleUnitImpl *oldUnit = nullptr;
+ for (int32_t i = 0; i < this->singleUnits.length(); i++) {
+ auto *candidate = this->singleUnits[i];
+ if (candidate->isCompatibleWith(singleUnit)) {
+ oldUnit = candidate;
+ }
+ }
+
+ if (oldUnit) {
+ // Both dimensionalities will be positive, or both will be negative, by
+ // virtue of isCompatibleWith().
+ oldUnit->dimensionality += singleUnit.dimensionality;
+
+ return false;
+ }
+
+ // Add a copy of singleUnit
+ // NOTE: MaybeStackVector::emplaceBackAndCheckErrorCode creates new copy of singleUnit.
+ this->singleUnits.emplaceBackAndCheckErrorCode(status, singleUnit);
+ if (U_FAILURE(status)) {
+ return false;
+ }
+
+ // If the MeasureUnitImpl is `UMEASURE_UNIT_SINGLE` and after the appending a unit, the `singleUnits`
+ // contains more than one. thus means the complexity should be `UMEASURE_UNIT_COMPOUND`
+ if (this->singleUnits.length() > 1 &&
+ this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_SINGLE) {
+ this->complexity = UMeasureUnitComplexity::UMEASURE_UNIT_COMPOUND;
+ }
+
+ return true;
+}
+
+MaybeStackVector<MeasureUnitImplWithIndex>
+MeasureUnitImpl::extractIndividualUnitsWithIndices(UErrorCode &status) const {
+ MaybeStackVector<MeasureUnitImplWithIndex> result;
+
+ if (this->complexity != UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+ result.emplaceBackAndCheckErrorCode(status, 0, *this, status);
+ return result;
+ }
+
+ for (int32_t i = 0; i < singleUnits.length(); ++i) {
+ result.emplaceBackAndCheckErrorCode(status, i, *singleUnits[i], status);
+ if (U_FAILURE(status)) {
+ return result;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * Normalize a MeasureUnitImpl and generate the identifier string in place.
+ */
+void MeasureUnitImpl::serialize(UErrorCode &status) {
+ if (U_FAILURE(status)) {
+ return;
+ }
+
+ if (this->singleUnits.length() == 0) {
+ // Dimensionless, constructed by the default constructor.
+ return;
+ }
+
+ if (this->complexity == UMEASURE_UNIT_COMPOUND) {
+ // Note: don't sort a MIXED unit
+ uprv_sortArray(this->singleUnits.getAlias(), this->singleUnits.length(),
+ sizeof(this->singleUnits[0]), compareSingleUnits, nullptr, false, &status);
+ if (U_FAILURE(status)) {
+ return;
+ }
+ }
+
+ CharString result;
+ bool beforePer = true;
+ bool firstTimeNegativeDimension = false;
+ for (int32_t i = 0; i < this->singleUnits.length(); i++) {
+ if (beforePer && (*this->singleUnits[i]).dimensionality < 0) {
+ beforePer = false;
+ firstTimeNegativeDimension = true;
+ } else if ((*this->singleUnits[i]).dimensionality < 0) {
+ firstTimeNegativeDimension = false;
+ }
+
+ if (U_FAILURE(status)) {
+ return;
+ }
+
+ if (this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+ if (result.length() != 0) {
+ result.append(StringPiece("-and-"), status);
+ }
+ } else {
+ if (firstTimeNegativeDimension) {
+ if (result.length() == 0) {
+ result.append(StringPiece("per-"), status);
+ } else {
+ result.append(StringPiece("-per-"), status);
+ }
+ } else {
+ if (result.length() != 0) {
+ result.append(StringPiece("-"), status);
+ }
+ }
+ }
+
+ this->singleUnits[i]->appendNeutralIdentifier(result, status);
+ }
+
+ this->identifier = CharString(result, status);
+}
+
+MeasureUnit MeasureUnitImpl::build(UErrorCode& status) && {
+ this->serialize(status);
+ return MeasureUnit(std::move(*this));
+}
+
+MeasureUnit MeasureUnit::forIdentifier(StringPiece identifier, UErrorCode& status) {
+ return Parser::from(identifier, status).parse(status).build(status);
+}
+
+UMeasureUnitComplexity MeasureUnit::getComplexity(UErrorCode& status) const {
+ MeasureUnitImpl temp;
+ return MeasureUnitImpl::forMeasureUnit(*this, temp, status).complexity;
+}
+
+UMeasurePrefix MeasureUnit::getPrefix(UErrorCode& status) const {
+ return SingleUnitImpl::forMeasureUnit(*this, status).unitPrefix;
+}
+
+MeasureUnit MeasureUnit::withPrefix(UMeasurePrefix prefix, UErrorCode& status) const UPRV_NO_SANITIZE_UNDEFINED {
+ SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
+ singleUnit.unitPrefix = prefix;
+ return singleUnit.build(status);
+}
+
+int32_t MeasureUnit::getDimensionality(UErrorCode& status) const {
+ SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
+ if (U_FAILURE(status)) { return 0; }
+ if (singleUnit.isDimensionless()) {
+ return 0;
+ }
+ return singleUnit.dimensionality;
+}
+
+MeasureUnit MeasureUnit::withDimensionality(int32_t dimensionality, UErrorCode& status) const {
+ SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
+ singleUnit.dimensionality = dimensionality;
+ return singleUnit.build(status);
+}
+
+MeasureUnit MeasureUnit::reciprocal(UErrorCode& status) const {
+ MeasureUnitImpl impl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
+ impl.takeReciprocal(status);
+ return std::move(impl).build(status);
+}
+
+MeasureUnit MeasureUnit::product(const MeasureUnit& other, UErrorCode& status) const {
+ MeasureUnitImpl impl = MeasureUnitImpl::forMeasureUnitMaybeCopy(*this, status);
+ MeasureUnitImpl temp;
+ const MeasureUnitImpl& otherImpl = MeasureUnitImpl::forMeasureUnit(other, temp, status);
+ if (impl.complexity == UMEASURE_UNIT_MIXED || otherImpl.complexity == UMEASURE_UNIT_MIXED) {
+ status = U_ILLEGAL_ARGUMENT_ERROR;
+ return {};
+ }
+ for (int32_t i = 0; i < otherImpl.singleUnits.length(); i++) {
+ impl.appendSingleUnit(*otherImpl.singleUnits[i], status);
+ }
+ if (impl.singleUnits.length() > 1) {
+ impl.complexity = UMEASURE_UNIT_COMPOUND;
+ }
+ return std::move(impl).build(status);
+}
+
+LocalArray<MeasureUnit> MeasureUnit::splitToSingleUnitsImpl(int32_t& outCount, UErrorCode& status) const {
+ MeasureUnitImpl temp;
+ const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(*this, temp, status);
+ outCount = impl.singleUnits.length();
+ MeasureUnit* arr = new MeasureUnit[outCount];
+ if (arr == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return LocalArray<MeasureUnit>();
+ }
+ for (int32_t i = 0; i < outCount; i++) {
+ arr[i] = impl.singleUnits[i]->build(status);
+ }
+ return LocalArray<MeasureUnit>(arr, status);
+}
+
+
+U_NAMESPACE_END
+
+#endif /* !UNCONFIG_NO_FORMATTING */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 12:06:00 +0000