| // © 2018 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| |
| #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 "fphdlimp.h" |
| #include "number_utypes.h" |
| #include "numparse_types.h" |
| #include "unicode/numberformatter.h" |
| #include "unicode/unumberformatter.h" |
| |
| using namespace icu; |
| using namespace icu::number; |
| using namespace icu::number::impl; |
| |
| |
| ////////////////////////////////// |
| /// C API CONVERSION FUNCTIONS /// |
| ////////////////////////////////// |
| |
| UNumberFormatterData* UNumberFormatterData::validate(UNumberFormatter* input, UErrorCode& status) { |
| auto* constInput = static_cast<const UNumberFormatter*>(input); |
| auto* validated = validate(constInput, status); |
| return const_cast<UNumberFormatterData*>(validated); |
| } |
| |
| const UNumberFormatterData* |
| UNumberFormatterData::validate(const UNumberFormatter* input, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return nullptr; |
| } |
| if (input == nullptr) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return nullptr; |
| } |
| auto* impl = reinterpret_cast<const UNumberFormatterData*>(input); |
| if (impl->fMagic != UNumberFormatterData::kMagic) { |
| status = U_INVALID_FORMAT_ERROR; |
| return nullptr; |
| } |
| return impl; |
| } |
| |
| UNumberFormatter* UNumberFormatterData::exportForC() { |
| return reinterpret_cast<UNumberFormatter*>(this); |
| } |
| |
| UFormattedNumberData* UFormattedNumberData::validate(UFormattedNumber* input, UErrorCode& status) { |
| auto* constInput = static_cast<const UFormattedNumber*>(input); |
| auto* validated = validate(constInput, status); |
| return const_cast<UFormattedNumberData*>(validated); |
| } |
| |
| const UFormattedNumberData* |
| UFormattedNumberData::validate(const UFormattedNumber* input, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return nullptr; |
| } |
| if (input == nullptr) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return nullptr; |
| } |
| auto* impl = reinterpret_cast<const UFormattedNumberData*>(input); |
| if (impl->fMagic != UFormattedNumberData::kMagic) { |
| status = U_INVALID_FORMAT_ERROR; |
| return nullptr; |
| } |
| return impl; |
| } |
| |
| UFormattedNumber* UFormattedNumberData::exportForC() { |
| return reinterpret_cast<UFormattedNumber*>(this); |
| } |
| |
| ///////////////////////////////////// |
| /// END CAPI CONVERSION FUNCTIONS /// |
| ///////////////////////////////////// |
| |
| |
| U_CAPI UNumberFormatter* U_EXPORT2 |
| unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const char* locale, |
| UErrorCode* ec) { |
| auto* impl = new UNumberFormatterData(); |
| if (impl == nullptr) { |
| *ec = U_MEMORY_ALLOCATION_ERROR; |
| return nullptr; |
| } |
| // Readonly-alias constructor (first argument is whether we are NUL-terminated) |
| UnicodeString skeletonString(skeletonLen == -1, skeleton, skeletonLen); |
| impl->fFormatter = NumberFormatter::forSkeleton(skeletonString, *ec).locale(locale); |
| return impl->exportForC(); |
| } |
| |
| U_CAPI UFormattedNumber* U_EXPORT2 |
| unumf_openResult(UErrorCode* ec) { |
| auto* impl = new UFormattedNumberData(); |
| if (impl == nullptr) { |
| *ec = U_MEMORY_ALLOCATION_ERROR; |
| return nullptr; |
| } |
| return impl->exportForC(); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_formatInt(const UNumberFormatter* uformatter, int64_t value, UFormattedNumber* uresult, |
| UErrorCode* ec) { |
| const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec); |
| UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return; } |
| |
| result->string.clear(); |
| result->quantity.setToLong(value); |
| formatter->fFormatter.formatImpl(result, *ec); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_formatDouble(const UNumberFormatter* uformatter, double value, UFormattedNumber* uresult, |
| UErrorCode* ec) { |
| const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec); |
| UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return; } |
| |
| result->string.clear(); |
| result->quantity.setToDouble(value); |
| formatter->fFormatter.formatImpl(result, *ec); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32_t valueLen, |
| UFormattedNumber* uresult, UErrorCode* ec) { |
| const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec); |
| UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return; } |
| |
| result->string.clear(); |
| result->quantity.setToDecNumber({value, valueLen}, *ec); |
| if (U_FAILURE(*ec)) { return; } |
| formatter->fFormatter.formatImpl(result, *ec); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t bufferCapacity, |
| UErrorCode* ec) { |
| const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return 0; } |
| |
| if (buffer == nullptr ? bufferCapacity != 0 : bufferCapacity < 0) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| return result->string.toTempUnicodeString().extract(buffer, bufferCapacity, *ec); |
| } |
| |
| U_CAPI UBool U_EXPORT2 |
| unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* ufpos, UErrorCode* ec) { |
| const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return FALSE; } |
| |
| if (ufpos == nullptr) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return FALSE; |
| } |
| |
| FieldPosition fp; |
| fp.setField(ufpos->field); |
| fp.setBeginIndex(ufpos->beginIndex); |
| fp.setEndIndex(ufpos->endIndex); |
| bool retval = result->string.nextFieldPosition(fp, *ec); |
| ufpos->beginIndex = fp.getBeginIndex(); |
| ufpos->endIndex = fp.getEndIndex(); |
| // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool |
| return retval ? TRUE : FALSE; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPositionIterator* ufpositer, |
| UErrorCode* ec) { |
| const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec); |
| if (U_FAILURE(*ec)) { return; } |
| |
| if (ufpositer == nullptr) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| auto* fpi = reinterpret_cast<FieldPositionIterator*>(ufpositer); |
| FieldPositionIteratorHandler fpih(fpi, *ec); |
| result->string.getAllFieldPositions(fpih, *ec); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_closeResult(UFormattedNumber* uresult) { |
| UErrorCode localStatus = U_ZERO_ERROR; |
| const UFormattedNumberData* impl = UFormattedNumberData::validate(uresult, localStatus); |
| delete impl; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| unumf_close(UNumberFormatter* f) { |
| UErrorCode localStatus = U_ZERO_ERROR; |
| const UNumberFormatterData* impl = UNumberFormatterData::validate(f, localStatus); |
| delete impl; |
| } |
| |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |