organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-04 21:15:35 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 8

ICU-20138 Adding FormattedValue APIs in C, C++, and Java.

Browse source 
- Wires up FormattedNumber[Range] in applicable languages.
- Adds new header files and tests, with minor cleanup to old tests.
- Adds code to guarantee terminating NUL in FormattedNumber[Range].
- Cleanup of API docs for inherited methods in FormattedNumber[Range].
This commit is contained in:
Shane Carr 2018-11-14 23:38:54 -08:00 • committed by Shane F. Carr
parent c3291233c4
commit 768b577e6a
44 changed files with 2907 additions and 418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
icu4c/source/common/capi_helper.h
View file

@ -25,7 +25,12 @@ class IcuCApiHelper {
static CPPType* validate(CType* input, UErrorCode& status);
/**
* Convert from the C++ type to the C type.
* Convert from the C++ type to the C type (const version).
*/
const CType* exportConstForC() const;
/**
* Convert from the C++ type to the C type (non-const version).
*/
CType* exportForC();
@ -53,7 +58,7 @@ IcuCApiHelper<CType, CPPType, kMagic>::validate(const CType* input, UErrorCode&
return nullptr;
}
auto* impl = reinterpret_cast<const CPPType*>(input);
if (impl->fMagic != kMagic) {
if (static_cast<const IcuCApiHelper<CType, CPPType, kMagic>*>(impl)->fMagic != kMagic) {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
@ -68,6 +73,12 @@ IcuCApiHelper<CType, CPPType, kMagic>::validate(CType* input, UErrorCode& status
return const_cast<CPPType*>(validated);
}
template<typename CType, typename CPPType, int32_t kMagic>
const CType*
IcuCApiHelper<CType, CPPType, kMagic>::exportConstForC() const {
return reinterpret_cast<const CType*>(static_cast<const CPPType*>(this));
}
template<typename CType, typename CPPType, int32_t kMagic>
CType*
IcuCApiHelper<CType, CPPType, kMagic>::exportForC() {

2
icu4c/source/i18n/Makefile.in
View file

@ -112,7 +112,7 @@ numparse_stringsegment.o numparse_parsednumber.o numparse_impl.o \
numparse_symbols.o numparse_decimal.o numparse_scientific.o numparse_currency.o \
numparse_affixes.o numparse_compositions.o numparse_validators.o \
numrange_fluent.o numrange_impl.o \
erarules.o
erarules.o formattedvalue.o
## Header files to install
HEADERS = $(srcdir)/unicode/*.h

205
icu4c/source/i18n/formattedvalue.cpp Normal file
View file

@ -0,0 +1,205 @@
// © 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
#include "unicode/formattedvalue.h"
#include "number_utypes.h"
#include "capi_helper.h"
U_NAMESPACE_BEGIN
ConstrainedFieldPosition::ConstrainedFieldPosition() {}
ConstrainedFieldPosition::~ConstrainedFieldPosition() {}
void ConstrainedFieldPosition::reset() {
fContext = 0LL;
fField = 0;
fStart = 0;
fLimit = 0;
fConstraint = UCFPOS_CONSTRAINT_NONE;
fCategory = UFIELD_CATEGORY_UNDEFINED;
}
void ConstrainedFieldPosition::constrainCategory(UFieldCategory category) {
fConstraint = UCFPOS_CONSTRAINT_CATEGORY;
fCategory = category;
}
void ConstrainedFieldPosition::constrainField(UFieldCategory category, int32_t field) {
fConstraint = UCFPOS_CONSTRAINT_FIELD;
fCategory = category;
fField = field;
}
void ConstrainedFieldPosition::setInt64IterationContext(int64_t context) {
fContext = context;
}
void ConstrainedFieldPosition::setState(
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit) {
fCategory = category;
fField = field;
fStart = start;
fLimit = limit;
}
FormattedValue::~FormattedValue() = default;
///////////////////////
/// C API FUNCTIONS ///
///////////////////////
struct UConstrainedFieldPositionImpl : public UMemory,
// Magic number as ASCII == "UCF"
public IcuCApiHelper<UConstrainedFieldPosition, UConstrainedFieldPositionImpl, 0x55434600> {
ConstrainedFieldPosition fImpl;
};
U_CAPI UConstrainedFieldPosition* U_EXPORT2
ucfpos_open(UErrorCode* ec) {
auto* impl = new UConstrainedFieldPositionImpl();
if (impl == nullptr) {
*ec = U_MEMORY_ALLOCATION_ERROR;
return nullptr;
}
return impl->exportForC();
}
U_CAPI void U_EXPORT2
ucfpos_reset(UConstrainedFieldPosition* ptr, UErrorCode* ec) {
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
impl->fImpl.reset();
}
U_CAPI void U_EXPORT2
ucfpos_constrainCategory(UConstrainedFieldPosition* ptr, UFieldCategory category, UErrorCode* ec) {
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
impl->fImpl.constrainCategory(category);
}
U_CAPI void U_EXPORT2
ucfpos_constrainField(UConstrainedFieldPosition* ptr, UFieldCategory category, int32_t field, UErrorCode* ec) {
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
impl->fImpl.constrainField(category, field);
}
U_CAPI UCFPosConstraintType U_EXPORT2
ucfpos_getConstraintType(const UConstrainedFieldPosition* ptr, UErrorCode* ec) {
const auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return UCFPOS_CONSTRAINT_NONE;
}
return impl->fImpl.getConstraintType();
}
U_CAPI UFieldCategory U_EXPORT2
ucfpos_getCategory(const UConstrainedFieldPosition* ptr, UErrorCode* ec) {
const auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return UFIELD_CATEGORY_UNDEFINED;
}
return impl->fImpl.getCategory();
}
U_CAPI int32_t U_EXPORT2
ucfpos_getField(const UConstrainedFieldPosition* ptr, UErrorCode* ec) {
const auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return 0;
}
return impl->fImpl.getField();
}
U_CAPI void U_EXPORT2
ucfpos_getIndexes(const UConstrainedFieldPosition* ptr, int32_t* pStart, int32_t* pLimit, UErrorCode* ec) {
const auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
*pStart = impl->fImpl.getStart();
*pLimit = impl->fImpl.getLimit();
}
U_CAPI int64_t U_EXPORT2
ucfpos_getInt64IterationContext(const UConstrainedFieldPosition* ptr, UErrorCode* ec) {
const auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return 0;
}
return impl->fImpl.getInt64IterationContext();
}
U_CAPI void U_EXPORT2
ucfpos_setInt64IterationContext(UConstrainedFieldPosition* ptr, int64_t context, UErrorCode* ec) {
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
impl->fImpl.setInt64IterationContext(context);
}
U_CAPI void U_EXPORT2
ucfpos_setState(
UConstrainedFieldPosition* ptr,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
UErrorCode* ec) {
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, *ec);
if (U_FAILURE(*ec)) {
return;
}
impl->fImpl.setState(category, field, start, limit);
}
U_CAPI void U_EXPORT2
ucfpos_close(UConstrainedFieldPosition* ptr) {
UErrorCode localStatus = U_ZERO_ERROR;
auto* impl = UConstrainedFieldPositionImpl::validate(ptr, localStatus);
delete impl;
}
U_DRAFT const UChar* U_EXPORT2
ufmtval_getString(
const UFormattedValue* ufmtval,
int32_t* pLength,
UErrorCode* ec) {
const auto* impl = number::impl::UFormattedValueApiHelper::validate(ufmtval, *ec);
if (U_FAILURE(*ec)) {
return nullptr;
}
UnicodeString readOnlyAlias = impl->fFormattedValue->toTempString(*ec);
if (U_FAILURE(*ec)) {
return nullptr;
}
if (pLength != nullptr) {
*pLength = readOnlyAlias.length();
}
return readOnlyAlias.getBuffer();
}
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */

1
icu4c/source/i18n/i18n.vcxproj
View file

@ -238,6 +238,7 @@
<ClCompile Include="fmtable.cpp" />
<ClCompile Include="fmtable_cnv.cpp" />
<ClCompile Include="format.cpp" />
<ClCompile Include="formattedvalue.cpp" />
<ClCompile Include="fphdlimp.cpp" />
<ClCompile Include="fpositer.cpp" />
<ClCompile Include="gender.cpp" />

3
icu4c/source/i18n/i18n.vcxproj.filters
View file

@ -156,6 +156,9 @@
<ClCompile Include="format.cpp">
<Filter>formatting</Filter>
</ClCompile>
<ClCompile Include="formattedvalue.cpp">
<Filter>formatting</Filter>
</ClCompile>
<ClCompile Include="fphdlimp.cpp">
<Filter>formatting</Filter>
</ClCompile>

1
icu4c/source/i18n/i18n_uwp.vcxproj
View file

@ -345,6 +345,7 @@
<ClCompile Include="fmtable.cpp" />
<ClCompile Include="fmtable_cnv.cpp" />
<ClCompile Include="format.cpp" />
<ClCompile Include="formattedvalue.cpp" />
<ClCompile Include="fphdlimp.cpp" />
<ClCompile Include="fpositer.cpp" />
<ClCompile Include="gender.cpp" />

93
icu4c/source/i18n/number_capi.cpp
View file

@ -20,6 +20,48 @@ using namespace icu::number;
using namespace icu::number::impl;
U_NAMESPACE_BEGIN
namespace number {
namespace impl {
/**
* Implementation class for UNumberFormatter. Wraps a LocalizedNumberFormatter.
*/
struct UNumberFormatterData : public UMemory,
// Magic number as ASCII == "NFR" (NumberFormatteR)
public IcuCApiHelper<UNumberFormatter, UNumberFormatterData, 0x4E465200> {
LocalizedNumberFormatter fFormatter;
};
struct UFormattedNumberImpl;
// Magic number as ASCII == "FDN" (FormatteDNumber)
typedef IcuCApiHelper<UFormattedNumber, UFormattedNumberImpl, 0x46444E00> UFormattedNumberApiHelper;
struct UFormattedNumberImpl : public UFormattedValueImpl, public UFormattedNumberApiHelper {
UFormattedNumberImpl();
~UFormattedNumberImpl();
FormattedNumber fImpl;
UFormattedNumberData fData;
};
UFormattedNumberImpl::UFormattedNumberImpl()
: fImpl(&fData) {
fFormattedValue = &fImpl;
}
UFormattedNumberImpl::~UFormattedNumberImpl() {
// Disown the data from fImpl so it doesn't get deleted twice
fImpl.fResults = nullptr;
}
}
}
U_NAMESPACE_END
U_CAPI UNumberFormatter* U_EXPORT2
unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const char* locale,
UErrorCode* ec) {
@ -36,55 +78,63 @@ unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const
U_CAPI UFormattedNumber* U_EXPORT2
unumf_openResult(UErrorCode* ec) {
auto* impl = new UFormattedNumberData();
auto* impl = new UFormattedNumberImpl();
if (impl == nullptr) {
*ec = U_MEMORY_ALLOCATION_ERROR;
return nullptr;
}
return impl->exportForC();
return static_cast<UFormattedNumberApiHelper*>(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);
auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return; }
result->string.clear();
result->quantity.setToLong(value);
formatter->fFormatter.formatImpl(result, *ec);
result->fData.string.clear();
result->fData.quantity.setToLong(value);
formatter->fFormatter.formatImpl(&result->fData, *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);
auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return; }
result->string.clear();
result->quantity.setToDouble(value);
formatter->fFormatter.formatImpl(result, *ec);
result->fData.string.clear();
result->fData.quantity.setToDouble(value);
formatter->fFormatter.formatImpl(&result->fData, *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);
auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return; }
result->string.clear();
result->quantity.setToDecNumber({value, valueLen}, *ec);
result->fData.string.clear();
result->fData.quantity.setToDecNumber({value, valueLen}, *ec);
if (U_FAILURE(*ec)) { return; }
formatter->fFormatter.formatImpl(result, *ec);
formatter->fFormatter.formatImpl(&result->fData, *ec);
}
U_DRAFT const UFormattedValue* U_EXPORT2
unumf_resultAsFormattedValue(const UFormattedNumber* uresult, UErrorCode* ec) {
const auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return nullptr; }
return static_cast<const UFormattedValueApiHelper*>(result)->exportConstForC();
}
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);
const auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return 0; }
if (buffer == nullptr ? bufferCapacity != 0 : bufferCapacity < 0) {
@ -92,12 +142,12 @@ unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t buf
return 0;
}
return result->string.toTempUnicodeString().extract(buffer, bufferCapacity, *ec);
return result->fImpl.toTempString(*ec).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);
const auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return FALSE; }
if (ufpos == nullptr) {
@ -109,7 +159,7 @@ unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* u
fp.setField(ufpos->field);
fp.setBeginIndex(ufpos->beginIndex);
fp.setEndIndex(ufpos->endIndex);
bool retval = result->string.nextFieldPosition(fp, *ec);
bool retval = result->fImpl.nextFieldPosition(fp, *ec);
ufpos->beginIndex = fp.getBeginIndex();
ufpos->endIndex = fp.getEndIndex();
// NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
@ -119,7 +169,7 @@ unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* u
U_CAPI void U_EXPORT2
unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPositionIterator* ufpositer,
UErrorCode* ec) {
const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
const auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
if (U_FAILURE(*ec)) { return; }
if (ufpositer == nullptr) {
@ -128,14 +178,13 @@ unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPosition
}
auto* fpi = reinterpret_cast<FieldPositionIterator*>(ufpositer);
FieldPositionIteratorHandler fpih(fpi, *ec);
result->string.getAllFieldPositions(fpih, *ec);
result->fImpl.getAllFieldPositions(*fpi, *ec);
}
U_CAPI void U_EXPORT2
unumf_closeResult(UFormattedNumber* uresult) {
UErrorCode localStatus = U_ZERO_ERROR;
const UFormattedNumberData* impl = UFormattedNumberData::validate(uresult, localStatus);
const UFormattedNumberImpl* impl = UFormattedNumberApiHelper::validate(uresult, localStatus);
delete impl;
}

27
icu4c/source/i18n/number_fluent.cpp
View file

@ -670,6 +670,10 @@ void LocalizedNumberFormatter::formatImpl(impl::UFormattedNumberData* results, U
} else {
NumberFormatterImpl::formatStatic(fMacros, results->quantity, results->string, status);
}
if (U_FAILURE(status)) {
return;
}
results->string.writeTerminator(status);
}
void LocalizedNumberFormatter::getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result,
@ -784,6 +788,17 @@ UnicodeString FormattedNumber::toString(UErrorCode& status) const {
return fResults->string.toUnicodeString();
}
UnicodeString FormattedNumber::toTempString(UErrorCode& status) const {
if (U_FAILURE(status)) {
return ICU_Utility::makeBogusString();
}
if (fResults == nullptr) {
status = fErrorCode;
return ICU_Utility::makeBogusString();
}
return fResults->string.toTempUnicodeString();
}
Appendable& FormattedNumber::appendTo(Appendable& appendable) {
UErrorCode localStatus = U_ZERO_ERROR;
return appendTo(appendable, localStatus);
@ -801,6 +816,18 @@ Appendable& FormattedNumber::appendTo(Appendable& appendable, UErrorCode& status
return appendable;
}
UBool FormattedNumber::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const {
if (U_FAILURE(status)) {
return FALSE;
}
if (fResults == nullptr) {
status = fErrorCode;
return FALSE;
}
// NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
return fResults->string.nextPosition(cfpos, status) ? TRUE : FALSE;
}
void FormattedNumber::populateFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) {
if (U_FAILURE(status)) {
return;

199
icu4c/source/i18n/number_stringbuilder.cpp
View file

@ -33,7 +33,15 @@ inline void uprv_memmove2(void* dest, const void* src, size_t len) {
} // namespace
NumberStringBuilder::NumberStringBuilder() = default;
NumberStringBuilder::NumberStringBuilder() {
#if U_DEBUG
// Initializing the memory to non-zero helps catch some bugs that involve
// reading from an improperly terminated string.
for (int32_t i=0; i<getCapacity(); i++) {
getCharPtr()[i] = 1;
}
#endif
};
NumberStringBuilder::~NumberStringBuilder() {
if (fUsingHeap) {
@ -241,6 +249,16 @@ NumberStringBuilder::insert(int32_t index, const NumberStringBuilder &other, UEr
return count;
}
void NumberStringBuilder::writeTerminator(UErrorCode& status) {
int32_t position = prepareForInsert(fLength, 1, status);
if (U_FAILURE(status)) {
return;
}
getCharPtr()[position] = 0;
getFieldPtr()[position] = UNUM_FIELD_COUNT;
fLength--;
}
int32_t NumberStringBuilder::prepareForInsert(int32_t index, int32_t count, UErrorCode &status) {
U_ASSERT(index >= 0);
U_ASSERT(index <= fLength);
@ -428,81 +446,107 @@ bool NumberStringBuilder::nextFieldPosition(FieldPosition& fp, UErrorCode& statu
return FALSE;
}
auto field = static_cast<Field>(rawField);
ConstrainedFieldPosition cfpos;
cfpos.constrainField(UFIELD_CATEGORY_NUMBER, rawField);
cfpos.setState(UFIELD_CATEGORY_NUMBER, rawField, fp.getBeginIndex(), fp.getEndIndex());
if (nextPosition(cfpos, status)) {
fp.setBeginIndex(cfpos.getStart());
fp.setEndIndex(cfpos.getLimit());
return true;
}
bool seenStart = false;
int32_t fractionStart = -1;
int32_t startIndex = fp.getEndIndex();
for (int32_t i = fZero + startIndex; i <= fZero + fLength; i++) {
Field _field = UNUM_FIELD_COUNT;
if (i < fZero + fLength) {
_field = getFieldPtr()[i];
}
if (seenStart && field != _field) {
// Special case: GROUPING_SEPARATOR counts as an INTEGER.
if (field == UNUM_INTEGER_FIELD && _field == UNUM_GROUPING_SEPARATOR_FIELD) {
continue;
}
fp.setEndIndex(i - fZero);
// Trim ignorables (whitespace, etc.) from the edge of the field.
UFieldPosition ufp = {0, fp.getBeginIndex(), fp.getEndIndex()};
if (trimFieldPosition(ufp)) {
fp.setBeginIndex(ufp.beginIndex);
fp.setEndIndex(ufp.endIndex);
// Special case: fraction should start after integer if fraction is not present
if (rawField == UNUM_FRACTION_FIELD && fp.getEndIndex() == 0) {
bool inside = false;
int32_t i = fZero;
for (; i < fZero + fLength; i++) {
if (isIntOrGroup(getFieldPtr()[i]) || getFieldPtr()[i] == UNUM_DECIMAL_SEPARATOR_FIELD) {
inside = true;
} else if (inside) {
break;
}
// This position was all ignorables; continue to the next position.
fp.setEndIndex(fp.getBeginIndex());
seenStart = false;
} else if (!seenStart && field == _field) {
fp.setBeginIndex(i - fZero);
seenStart = true;
}
if (_field == UNUM_INTEGER_FIELD || _field == UNUM_DECIMAL_SEPARATOR_FIELD) {
fractionStart = i - fZero + 1;
}
fp.setBeginIndex(i - fZero);
fp.setEndIndex(i - fZero);
}
// Backwards compatibility: FRACTION needs to start after INTEGER if empty.
// Do not return that a field was found, though, since there is not actually a fraction part.
if (field == UNUM_FRACTION_FIELD && !seenStart && fractionStart != -1) {
fp.setBeginIndex(fractionStart);
fp.setEndIndex(fractionStart);
}
return seenStart;
return false;
}
void NumberStringBuilder::getAllFieldPositions(FieldPositionIteratorHandler& fpih,
UErrorCode& status) const {
Field current = UNUM_FIELD_COUNT;
int32_t currentStart = -1;
for (int32_t i = 0; i < fLength; i++) {
Field field = fieldAt(i);
if (current == UNUM_INTEGER_FIELD && field == UNUM_GROUPING_SEPARATOR_FIELD) {
// Special case: GROUPING_SEPARATOR counts as an INTEGER.
// TODO(ICU-13064): Grouping separator can be more than 1 code unit.
fpih.addAttribute(UNUM_GROUPING_SEPARATOR_FIELD, i, i + 1);
} else if (current != field) {
if (current != UNUM_FIELD_COUNT) {
UFieldPosition fp = {0, currentStart, i};
if (trimFieldPosition(fp)) {
fpih.addAttribute(current, fp.beginIndex, fp.endIndex);
ConstrainedFieldPosition cfpos;
while (nextPosition(cfpos, status)) {
fpih.addAttribute(cfpos.getField(), cfpos.getStart(), cfpos.getLimit());
}
}
bool NumberStringBuilder::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& /*status*/) const {
bool isSearchingForField = false;
if (cfpos.getConstraintType() == UCFPOS_CONSTRAINT_CATEGORY) {
if (cfpos.getCategory() != UFIELD_CATEGORY_NUMBER) {
return false;
}
} else if (cfpos.getConstraintType() == UCFPOS_CONSTRAINT_FIELD) {
isSearchingForField = true;
}
int32_t fieldStart = -1;
int32_t currField = UNUM_FIELD_COUNT;
for (int32_t i = fZero + cfpos.getLimit(); i <= fZero + fLength; i++) {
Field _field = (i < fZero + fLength) ? getFieldPtr()[i] : UNUM_FIELD_COUNT;
// Case 1: currently scanning a field.
if (currField != UNUM_FIELD_COUNT) {
if (currField != _field) {
int32_t end = i - fZero;
// Grouping separators can be whitespace; don't throw them out!
if (currField != UNUM_GROUPING_SEPARATOR_FIELD) {
end = trimBack(i - fZero);
}
if (end <= fieldStart) {
// Entire field position is ignorable; skip.
fieldStart = -1;
currField = UNUM_FIELD_COUNT;
i--; // look at this index again
continue;
}
int32_t start = fieldStart;
if (currField != UNUM_GROUPING_SEPARATOR_FIELD) {
start = trimFront(start);
}
cfpos.setState(UFIELD_CATEGORY_NUMBER, currField, start, end);
return true;
}
current = field;
currentStart = i;
continue;
}
if (U_FAILURE(status)) {
return;
}
}
if (current != UNUM_FIELD_COUNT) {
UFieldPosition fp = {0, currentStart, fLength};
if (trimFieldPosition(fp)) {
fpih.addAttribute(current, fp.beginIndex, fp.endIndex);
// Special case: coalesce the INTEGER if we are pointing at the end of the INTEGER.
if ((!isSearchingForField || cfpos.getField() == UNUM_INTEGER_FIELD)
&& i > fZero
&& i - fZero > cfpos.getLimit() // don't return the same field twice in a row
&& isIntOrGroup(getFieldPtr()[i - 1])
&& !isIntOrGroup(_field)) {
int j = i - 1;
for (; j >= fZero && isIntOrGroup(getFieldPtr()[j]); j--) {}
cfpos.setState(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD, j - fZero + 1, i - fZero);
return true;
}
// Special case: skip over INTEGER; will be coalesced later.
if (_field == UNUM_INTEGER_FIELD) {
_field = UNUM_FIELD_COUNT;
}
// Case 2: no field starting at this position.
if (_field == UNUM_FIELD_COUNT) {
continue;
}
// Case 3: check for field starting at this position
if (!isSearchingForField || cfpos.getField() == _field) {
fieldStart = i - fZero;
currField = _field;
}
}
U_ASSERT(currField == UNUM_FIELD_COUNT);
return false;
}
bool NumberStringBuilder::containsField(Field field) const {
@ -514,26 +558,23 @@ bool NumberStringBuilder::containsField(Field field) const {
return false;
}
bool NumberStringBuilder::trimFieldPosition(UFieldPosition& fp) const {
// Trim ignorables from the back
int32_t endIgnorablesRelPos = unisets::get(unisets::DEFAULT_IGNORABLES)->spanBack(
getCharPtr() + fZero + fp.beginIndex,
fp.endIndex - fp.beginIndex,
USET_SPAN_CONTAINED);
bool NumberStringBuilder::isIntOrGroup(Field field) {
return field == UNUM_INTEGER_FIELD
|| field ==UNUM_GROUPING_SEPARATOR_FIELD;
}
// Check if the entire segment is ignorables
if (endIgnorablesRelPos == 0) {
return false;
}
fp.endIndex = fp.beginIndex + endIgnorablesRelPos;
// Trim ignorables from the front
int32_t startIgnorablesRelPos = unisets::get(unisets::DEFAULT_IGNORABLES)->span(
getCharPtr() + fZero + fp.beginIndex,
fp.endIndex - fp.beginIndex,
int32_t NumberStringBuilder::trimBack(int32_t limit) const {
return unisets::get(unisets::DEFAULT_IGNORABLES)->spanBack(
getCharPtr() + fZero,
limit,
USET_SPAN_CONTAINED);
}
int32_t NumberStringBuilder::trimFront(int32_t start) const {
return start + unisets::get(unisets::DEFAULT_IGNORABLES)->span(
getCharPtr() + fZero + start,
fLength - start,
USET_SPAN_CONTAINED);
fp.beginIndex = fp.beginIndex + startIgnorablesRelPos;
return true;
}
#endif /* #if !UCONFIG_NO_FORMATTING */

10
icu4c/source/i18n/number_stringbuilder.h
View file

@ -85,6 +85,8 @@ class U_I18N_API NumberStringBuilder : public UMemory {
int32_t insert(int32_t index, const NumberStringBuilder &other, UErrorCode &status);
void writeTerminator(UErrorCode& status);
/**
* Gets a "safe" UnicodeString that can be used even after the NumberStringBuilder is destructed.
* */
@ -106,6 +108,8 @@ class U_I18N_API NumberStringBuilder : public UMemory {
void getAllFieldPositions(FieldPositionIteratorHandler& fpih, UErrorCode& status) const;
bool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const;
bool containsField(Field field) const;
private:
@ -141,7 +145,11 @@ class U_I18N_API NumberStringBuilder : public UMemory {
int32_t remove(int32_t index, int32_t count);
bool trimFieldPosition(UFieldPosition& fpos) const;
static bool isIntOrGroup(Field field);
int32_t trimBack(int32_t limit) const;
int32_t trimFront(int32_t start) const;
};
} // namespace impl

22
icu4c/source/i18n/number_utypes.h
View file

@ -17,28 +17,26 @@ U_NAMESPACE_BEGIN namespace number {
namespace impl {
/**
* Implementation class for UNumberFormatter. Wraps a LocalizedNumberFormatter.
*/
struct UNumberFormatterData : public UMemory,
// Magic number as ASCII == "NFR" (NumberFormatteR)
public IcuCApiHelper<UNumberFormatter, UNumberFormatterData, 0x4E465200> {
LocalizedNumberFormatter fFormatter;
struct UFormattedValueImpl;
// Magic number as ASCII == "UFV"
typedef IcuCApiHelper<UFormattedValue, UFormattedValueImpl, 0x55465600> UFormattedValueApiHelper;
struct UFormattedValueImpl : public UMemory, public UFormattedValueApiHelper {
FormattedValue* fFormattedValue = nullptr;
};
/**
* Implementation class for UFormattedNumber.
* Struct for data used by FormattedNumber.
*
* This struct is also held internally by the C++ version FormattedNumber since the member types are not
* This struct is held internally by the C++ version FormattedNumber since the member types are not
* declared in the public header file.
*
* The DecimalQuantity is not currently being used by FormattedNumber, but at some point it could be used
* to add a toDecNumber() or similar method.
*/
struct UFormattedNumberData : public UMemory,
// Magic number as ASCII == "FDN" (FormatteDNumber)
public IcuCApiHelper<UFormattedNumber, UFormattedNumberData, 0x46444E00> {
struct UFormattedNumberData : public UMemory {
DecimalQuantity quantity;
NumberStringBuilder string;
};

27
icu4c/source/i18n/numrange_fluent.cpp
View file

@ -318,6 +318,10 @@ void LocalizedNumberRangeFormatter::formatImpl(
return;
}
impl->format(results, equalBeforeRounding, status);
if (U_FAILURE(status)) {
return;
}
results.string.writeTerminator(status);
}
const impl::NumberRangeFormatterImpl*
@ -389,6 +393,17 @@ UnicodeString FormattedNumberRange::toString(UErrorCode& status) const {
return fResults->string.toUnicodeString();
}
UnicodeString FormattedNumberRange::toTempString(UErrorCode& status) const {
if (U_FAILURE(status)) {
return ICU_Utility::makeBogusString();
}
if (fResults == nullptr) {
status = fErrorCode;
return ICU_Utility::makeBogusString();
}
return fResults->string.toTempUnicodeString();
}
Appendable& FormattedNumberRange::appendTo(Appendable& appendable, UErrorCode& status) const {
if (U_FAILURE(status)) {
return appendable;
@ -401,6 +416,18 @@ Appendable& FormattedNumberRange::appendTo(Appendable& appendable, UErrorCode& s
return appendable;
}
UBool FormattedNumberRange::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const {
if (U_FAILURE(status)) {
return FALSE;
}
if (fResults == nullptr) {
status = fErrorCode;
return FALSE;
}
// NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
return fResults->string.nextPosition(cfpos, status) ? TRUE : FALSE;
}
UBool FormattedNumberRange::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
if (U_FAILURE(status)) {
return FALSE;

314
icu4c/source/i18n/unicode/formattedvalue.h Normal file
View file

@ -0,0 +1,314 @@
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
#ifndef __FORMATTEDVALUE_H__
#define __FORMATTEDVALUE_H__
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/appendable.h"
#include "unicode/fpositer.h"
#include "unicode/unistr.h"
#include "unicode/uformattedvalue.h"
U_NAMESPACE_BEGIN
/**
* \file
* \brief C++ API: Abstract operations for localized strings.
*
* This file contains declarations for classes that deal with formatted strings. A number
* of APIs throughout ICU use these classes for expressing their localized output.
*/
/**
* Represents a span of a string containing a given field.
*
* This class differs from FieldPosition in the following ways:
*
* 1. It has information on the field category.
* 2. It allows you to set constraints to use when iterating over field positions.
* 3. It is used for the newer FormattedValue APIs.
*
* This class is not intended for public subclassing.
*
* @draft ICU 64
*/
class U_I18N_API ConstrainedFieldPosition : public UMemory {
public:
/**
* Initializes a ConstrainedFieldPosition.
*
* By default, the ConstrainedFieldPosition has no iteration constraints.
*
* @draft ICU 64
*/
ConstrainedFieldPosition();
/** @draft ICU 64 */
~ConstrainedFieldPosition();
/**
* Resets this ConstrainedFieldPosition to its initial state, as if it were newly created:
*
* - Removes any constraints that may have been set on the instance.
* - Resets the iteration position.
*
* @draft ICU 64
*/
void reset();
/**
* Sets a constraint on the field category.
*
* When this instance of ConstrainedFieldPosition is passed to FormattedValue#nextPosition,
* positions are skipped unless they have the given category.
*
* Any previously set constraints are cleared.
*
* For example, to loop over only the number-related fields:
*
* ConstrainedFieldPosition cfpos;
* cfpos.constrainCategory(UFIELDCATEGORY_NUMBER_FORMAT);
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the number-related field position
* }
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param category The field category to fix when iterating.
* @draft ICU 64
*/
void constrainCategory(UFieldCategory category);
/**
* Sets a constraint on the category and field.
*
* When this instance of ConstrainedFieldPosition is passed to FormattedValue#nextPosition,
* positions are skipped unless they have the given category and field.
*
* Any previously set constraints are cleared.
*
* For example, to loop over all grouping separators:
*
* ConstrainedFieldPosition cfpos;
* cfpos.constrainField(UFIELDCATEGORY_NUMBER_FORMAT, UNUM_GROUPING_SEPARATOR_FIELD);
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the grouping separator position
* }
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param category The field category to fix when iterating.
* @param field The field to fix when iterating.
* @draft ICU 64
*/
void constrainField(UFieldCategory category, int32_t field);
/**
* Gets the currently active constraint.
*
* @return The currently active constraint type.
* @draft ICU 64
*/
inline UCFPosConstraintType getConstraintType() const {
return fConstraint;
}
/**
* Gets the field category for the current position.
*
* If a category or field constraint was set, this function returns the constrained
* category. Otherwise, the return value is well-defined only after
* FormattedValue#nextPosition returns TRUE.
*
* @return The field category saved in the instance.
* @draft ICU 64
*/
inline UFieldCategory getCategory() const {
return fCategory;
};
/**
* Gets the field for the current position.
*
* If a field constraint was set, this function returns the constrained
* field. Otherwise, the return value is well-defined only after
* FormattedValue#nextPosition returns TRUE.
*
* @return The field saved in the instance.
* @draft ICU 64
*/
inline int32_t getField() const {
return fField;
};
/**
* Gets the INCLUSIVE start index for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The start index saved in the instance.
* @draft ICU 64
*/
inline int32_t getStart() const {
return fStart;
};
/**
* Gets the EXCLUSIVE end index stored for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The end index saved in the instance.
* @draft ICU 64
*/
inline int32_t getLimit() const {
return fLimit;
};
////////////////////////////////////////////////////////////////////
//// The following methods are for FormattedValue implementers; ////
//// most users can ignore them. ////
////////////////////////////////////////////////////////////////////
/**
* Gets an int64 that FormattedValue implementations may use for storage.
*
* The initial value is zero.
*
* Users of FormattedValue should not need to call this method.
*
* @return The current iteration context from {@link #setInt64IterationContext}.
* @draft ICU 64
*/
inline int64_t getInt64IterationContext() const {
return fContext;
}
/**
* Sets an int64 that FormattedValue implementations may use for storage.
*
* Intended to be used by FormattedValue implementations.
*
* @param context The new iteration context.
* @draft ICU 64
*/
void setInt64IterationContext(int64_t context);
/**
* Sets new values for the primary public getters.
*
* Intended to be used by FormattedValue implementations.
*
* It is up to the implementation to ensure that the user-requested
* constraints are satisfied. This method does not check!
*
* @param category The new field category.
* @param field The new field.
* @param start The new inclusive start index.
* @param limit The new exclusive end index.
* @draft ICU 64
*/
void setState(
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit);
private:
int64_t fContext = 0LL;
int32_t fField = 0;
int32_t fStart = 0;
int32_t fLimit = 0;
UCFPosConstraintType fConstraint = UCFPOS_CONSTRAINT_NONE;
UFieldCategory fCategory = UFIELD_CATEGORY_UNDEFINED;
};
/**
* An abstract formatted value: a string with associated field attributes.
* Many formatters format to classes implementing FormattedValue.
*
* @draft ICU 64
*/
class U_I18N_API FormattedValue /* not : public UObject because this is an interface/mixin class */ {
public:
virtual ~FormattedValue();
/**
* Returns the formatted string as a self-contained UnicodeString.
*
* If you need the string within the current scope only, consider #toTempString.
*
* @param status Set if an error occurs.
* @return a UnicodeString containing the formatted string.
*
* @draft ICU 64
*/
virtual UnicodeString toString(UErrorCode& status) const = 0;
/**
* Returns the formatted string as a read-only alias to memory owned by the FormattedValue.
*
* The return value is valid only as long as this FormattedValue is present and unchanged in
* memory. If you need the string outside the current scope, consider #toString.
*
* The buffer returned by calling UnicodeString#getBuffer() on the return value is
* guaranteed to be NUL-terminated.
*
* @param status Set if an error occurs.
* @return a temporary UnicodeString containing the formatted string.
*
* @draft ICU 64
*/
virtual UnicodeString toTempString(UErrorCode& status) const = 0;
/**
* Appends the formatted string to an Appendable.
*
* @param appendable
* The Appendable to which to append the string output.
* @param status Set if an error occurs.
* @return The same Appendable, for chaining.
*
* @draft ICU 64
* @see Appendable
*/
virtual Appendable& appendTo(Appendable& appendable, UErrorCode& status) const = 0;
/**
* Iterates over field positions in the FormattedValue. This lets you determine the position
* of specific types of substrings, like a month or a decimal separator.
*
* To loop over all field positions:
*
* ConstrainedFieldPosition cfpos;
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the field position; get information from cfpos
* }
*
* @param cfpos
* The object used for iteration state. This can provide constraints to iterate over
* only one specific category or field;
* see ConstrainedFieldPosition#constrainCategory
* and ConstrainedFieldPosition#constrainField.
* @param status Set if an error occurs.
* @return TRUE if a new occurrence of the field was found;
* FALSE otherwise or if an error was set.
*
* @draft ICU 64
*/
virtual UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const = 0;
};
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif // __FORMATTEDVALUE_H__

109
icu4c/source/i18n/unicode/numberformatter.h
View file

@ -11,6 +11,7 @@
#include "unicode/dcfmtsym.h"
#include "unicode/currunit.h"
#include "unicode/fieldpos.h"
#include "unicode/formattedvalue.h"
#include "unicode/fpositer.h"
#include "unicode/measunit.h"
#include "unicode/nounit.h"
@ -146,6 +147,7 @@ class GeneratorHelpers;
class DecNum;
class NumberRangeFormatterImpl;
struct RangeMacroProps;
struct UFormattedNumberImpl;
/**
* Used for NumberRangeFormatter and implemented in numrange_fluent.cpp.
@ -2447,8 +2449,45 @@ class U_I18N_API LocalizedNumberFormatter
*
* @draft ICU 60
*/
class U_I18N_API FormattedNumber : public UMemory {
class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
public:
/**
* Default constructor; makes an empty FormattedNumber.
*/
FormattedNumber()
: fResults(nullptr), fErrorCode(U_INVALID_STATE_ERROR) {};
/**
* Copying not supported; use move constructor instead.
*/
FormattedNumber(const FormattedNumber&) = delete;
/**
* Move constructor:
* Leaves the source FormattedNumber in an undefined state.
* @draft ICU 62
*/
FormattedNumber(FormattedNumber&& src) U_NOEXCEPT;
/**
* Destruct an instance of FormattedNumber, cleaning up any memory it might own.
* @draft ICU 60
*/
virtual ~FormattedNumber() U_OVERRIDE;
/**
* Copying not supported; use move assignment instead.
*/
FormattedNumber& operator=(const FormattedNumber&) = delete;
/**
* Move assignment:
* Leaves the source FormattedNumber in an undefined state.
* @draft ICU 62
*/
FormattedNumber& operator=(FormattedNumber&& src) U_NOEXCEPT;
#ifndef U_HIDE_DEPRECATED_API
/**
* Returns a UnicodeString representation of the formatted number.
@ -2462,14 +2501,14 @@ class U_I18N_API FormattedNumber : public UMemory {
#endif /* U_HIDE_DEPRECATED_API */
/**
* Returns a UnicodeString representation of the formatted number.
*
* @param status
* Set if an error occurs while formatting the number to the UnicodeString.
* @return a UnicodeString containing the localized number.
* @draft ICU 62
* @copydoc FormattedValue::toString()
*/
UnicodeString toString(UErrorCode& status) const;
UnicodeString toString(UErrorCode& status) const U_OVERRIDE;
/**
* @copydoc FormattedValue::toTempString()
*/
UnicodeString toTempString(UErrorCode& status) const U_OVERRIDE;
#ifndef U_HIDE_DEPRECATED_API
/**
@ -2483,21 +2522,18 @@ class U_I18N_API FormattedNumber : public UMemory {
* See http://bugs.icu-project.org/trac/ticket/13746
* @see Appendable
*/
Appendable &appendTo(Appendable &appendable);
Appendable &appendTo(Appendable& appendable);
#endif /* U_HIDE_DEPRECATED_API */
/**
* Appends the formatted number to an Appendable.
*
* @param appendable
* The Appendable to which to append the formatted number string.
* @param status
* Set if an error occurs while formatting the number to the Appendable.
* @return The same Appendable, for chaining.
* @draft ICU 62
* @see Appendable
* @copydoc FormattedValue::appendTo()
*/
Appendable &appendTo(Appendable &appendable, UErrorCode& status) const;
Appendable &appendTo(Appendable& appendable, UErrorCode& status) const U_OVERRIDE;
/**
* @copydoc FormattedValue::nextPosition()
*/
UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const U_OVERRIDE;
#ifndef U_HIDE_DEPRECATED_API
/**
@ -2606,39 +2642,9 @@ class U_I18N_API FormattedNumber : public UMemory {
#endif /* U_HIDE_INTERNAL_API */
/**
* Copying not supported; use move constructor instead.
*/
FormattedNumber(const FormattedNumber&) = delete;
/**
* Copying not supported; use move assignment instead.
*/
FormattedNumber& operator=(const FormattedNumber&) = delete;
/**
* Move constructor:
* Leaves the source FormattedNumber in an undefined state.
* @draft ICU 62
*/
FormattedNumber(FormattedNumber&& src) U_NOEXCEPT;
/**
* Move assignment:
* Leaves the source FormattedNumber in an undefined state.
* @draft ICU 62
*/
FormattedNumber& operator=(FormattedNumber&& src) U_NOEXCEPT;
/**
* Destruct an instance of FormattedNumber, cleaning up any memory it might own.
* @draft ICU 60
*/
~FormattedNumber();
private:
// Can't use LocalPointer because UFormattedNumberData is forward-declared
const impl::UFormattedNumberData *fResults;
impl::UFormattedNumberData *fResults;
// Error code for the terminal methods
UErrorCode fErrorCode;
@ -2655,6 +2661,9 @@ class U_I18N_API FormattedNumber : public UMemory {
// To give LocalizedNumberFormatter format methods access to this class's constructor:
friend class LocalizedNumberFormatter;
// To give C API access to internals
friend struct impl::UFormattedNumberImpl;
};
/**

34
icu4c/source/i18n/unicode/numberrangeformatter.h
View file

@ -8,6 +8,7 @@
#include <atomic>
#include "unicode/appendable.h"
#include "unicode/fieldpos.h"
#include "unicode/formattedvalue.h"
#include "unicode/fpositer.h"
#include "unicode/numberformatter.h"
@ -662,30 +663,27 @@ class U_I18N_API LocalizedNumberRangeFormatter
*
* @draft ICU 63
*/
class U_I18N_API FormattedNumberRange : public UMemory {
class U_I18N_API FormattedNumberRange : public UMemory, public FormattedValue {
public:
/**
* Returns a UnicodeString representation of the formatted number range.
*
* @param status
* Set if an error occurs while formatting the number to the UnicodeString.
* @return a UnicodeString containing the localized number range.
* @draft ICU 63
* @copydoc FormattedValue::toString()
*/
UnicodeString toString(UErrorCode& status) const;
UnicodeString toString(UErrorCode& status) const U_OVERRIDE;
/**
* Appends the formatted number range to an Appendable.
*
* @param appendable
* The Appendable to which to append the formatted number range string.
* @param status
* Set if an error occurs while formatting the number range to the Appendable.
* @return The same Appendable, for chaining.
* @draft ICU 63
* @see Appendable
* @copydoc FormattedValue::toTempString()
*/
Appendable &appendTo(Appendable &appendable, UErrorCode& status) const;
UnicodeString toTempString(UErrorCode& status) const U_OVERRIDE;
/**
* @copydoc FormattedValue::appendTo()
*/
Appendable &appendTo(Appendable &appendable, UErrorCode& status) const U_OVERRIDE;
/**
* @copydoc FormattedValue::nextPosition()
*/
UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const U_OVERRIDE;
/**
* Determines the start (inclusive) and end (exclusive) indices of the next occurrence of the given

442
icu4c/source/i18n/unicode/uformattedvalue.h Normal file
View file

@ -0,0 +1,442 @@
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
#ifndef __UFORMATTEDVALUE_H__
#define __UFORMATTEDVALUE_H__
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/ufieldpositer.h"
/**
* \file
* \brief C API: Abstract operations for localized strings.
*
* This file contains declarations for classes that deal with formatted strings. A number
* of APIs throughout ICU use these classes for expressing their localized output.
*/
/**
* All possible field categories in ICU. Every entry in this enum corresponds
* to another enum that exists in ICU.
*
* @draft ICU 64
*/
typedef enum UFieldCategory {
/**
* For an undefined field category.
*
* @draft ICU 64
*/
UFIELD_CATEGORY_UNDEFINED = 0,
/**
* For fields in UDateFormatField (udat.h), from ICU 3.0.
*
* @draft ICU 64
*/
UFIELD_CATEGORY_DATE,
/**
* For fields in UNumberFormatFields (unum.h), from ICU 49.
*
* @draft ICU 64
*/
UFIELD_CATEGORY_NUMBER,
/**
* For fields in UListFormatterField (ulistformatter.h), from ICU 63.
*
* @draft ICU 64
*/
UFIELD_CATEGORY_LIST,
} UFieldCategory;
/**
* Represents the type of constraint for ConstrainedFieldPosition.
*
* Constraints are used to control the behavior of iteration in FormattedValue.
*
* @draft ICU 64
*/
typedef enum UCFPosConstraintType {
/**
* Represents the lack of a constraint.
*
* This is the return value of ConstrainedFieldPosition#getConstraintType or
* ucfpos_getConstraintType if no "constrain" methods were called.
*
* @draft ICU 64
*/
UCFPOS_CONSTRAINT_NONE,
/**
* Represents that the field category is constrained.
*
* This is the return value of ConstrainedFieldPosition#getConstraintType or
* cfpos_getConstraintType after ConstrainedFieldPosition#constrainCategory or
* cfpos_constrainCategory is called.
*
* Use getCategory to access the category. FormattedValue implementations
* should not change that values while this constraint is active.
*
* @draft ICU 64
*/
UCFPOS_CONSTRAINT_CATEGORY,
/**
* Represents that the field and field category are constrained.
*
* This is the return value of ConstrainedFieldPosition#getConstraintType or
* cfpos_getConstraintType after ConstrainedFieldPosition#constrainField or
* cfpos_constrainField is called.
*
* Use getCategory and getField to access the category and field.
* FormattedValue implementations should not change those values while
* this constraint is active.
*
* @draft ICU 64
*/
UCFPOS_CONSTRAINT_FIELD
} UCFPosConstraintType;
struct UConstrainedFieldPosition;
/**
* Represents a span of a string containing a given field.
*
* This struct differs from UFieldPosition in the following ways:
*
* 1. It has information on the field category.
* 2. It allows you to set constraints to use when iterating over field positions.
* 3. It is used for the newer FormattedValue APIs.
*
* @draft ICU 64
*/
typedef struct UConstrainedFieldPosition UConstrainedFieldPosition;
/**
* Creates a new UConstrainedFieldPosition.
*
* By default, the UConstrainedFieldPosition has no iteration constraints.
*
* @param ec Set if an error occurs.
* @return The new object, or NULL if an error occurs.
* @draft ICU 64
*/
U_DRAFT UConstrainedFieldPosition* U_EXPORT2
ucfpos_open(UErrorCode* ec);
/**
* Resets a UConstrainedFieldPosition to its initial state, as if it were newly created.
*
* Removes any constraints that may have been set on the instance.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_reset(
UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
/**
* Destroys a UConstrainedFieldPosition and releases its memory.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_close(UConstrainedFieldPosition* ucfpos);
/**
* Sets a constraint on the field category.
*
* When this instance of UConstrainedFieldPosition is passed to ufmtval_nextPosition,
* positions are skipped unless they have the given category.
*
* Any previously set constraints are cleared.
*
* For example, to loop over only the number-related fields:
*
* UConstrainedFieldPosition* ucfpos = ucfpos_open(ec);
* ucfpos_constrainCategory(ucfpos, UFIELDCATEGORY_NUMBER_FORMAT, ec);
* while (ufmtval_nextPosition(ufmtval, ucfpos, ec)) {
* // handle the number-related field position
* }
* ucfpos_close(ucfpos);
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param category The field category to fix when iterating.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_constrainCategory(
UConstrainedFieldPosition* ucfpos,
UFieldCategory category,
UErrorCode* ec);
/**
* Sets a constraint on the category and field.
*
* When this instance of UConstrainedFieldPosition is passed to ufmtval_nextPosition,
* positions are skipped unless they have the given category and field.
*
* Any previously set constraints are cleared.
*
* For example, to loop over all grouping separators:
*
* UConstrainedFieldPosition* ucfpos = ucfpos_open(ec);
* ucfpos_constrainField(ucfpos, UFIELDCATEGORY_NUMBER_FORMAT, UNUM_GROUPING_SEPARATOR_FIELD, ec);
* while (ufmtval_nextPosition(ufmtval, ucfpos, ec)) {
* // handle the grouping separator position
* }
* ucfpos_close(ucfpos);
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param category The field category to fix when iterating.
* @param field The field to fix when iterating.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_constrainField(
UConstrainedFieldPosition* ucfpos,
UFieldCategory category,
int32_t field,
UErrorCode* ec);
/**
* Gets the currently active constraint.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param ec Set if an error occurs.
* @return The currently active constraint type.
* @draft ICU 64
*/
U_DRAFT UCFPosConstraintType U_EXPORT2
ucfpos_getConstraintType(
const UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
/**
* Gets the field category for the current position.
*
* If a category or field constraint was set, this function returns the constrained
* category. Otherwise, the return value is well-defined only after
* ufmtval_nextPosition returns TRUE.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param ec Set if an error occurs.
* @return The field category saved in the instance.
* @draft ICU 64
*/
U_DRAFT UFieldCategory U_EXPORT2
ucfpos_getCategory(
const UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
/**
* Gets the field for the current position.
*
* If a field constraint was set, this function returns the constrained
* field. Otherwise, the return value is well-defined only after
* ufmtval_nextPosition returns TRUE.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param ec Set if an error occurs.
* @return The field saved in the instance.
* @draft ICU 64
*/
U_DRAFT int32_t U_EXPORT2
ucfpos_getField(
const UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
/**
* Gets the INCLUSIVE start and EXCLUSIVE end index stored for the current position.
*
* The output values are well-defined only after ufmtval_nextPosition returns TRUE.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param pStart Set to the start index saved in the instance. Ignored if nullptr.
* @param pLimit Set to the end index saved in the instance. Ignored if nullptr.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_getIndexes(
const UConstrainedFieldPosition* ucfpos,
int32_t* pStart,
int32_t* pLimit,
UErrorCode* ec);
/**
* Gets an int64 that FormattedValue implementations may use for storage.
*
* The initial value is zero.
*
* Users of FormattedValue should not need to call this method.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param ec Set if an error occurs.
* @return The current iteration context from ucfpos_setInt64IterationContext.
* @draft ICU 64
*/
U_DRAFT int64_t U_EXPORT2
ucfpos_getInt64IterationContext(
const UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
/**
* Sets an int64 that FormattedValue implementations may use for storage.
*
* Intended to be used by FormattedValue implementations.
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param context The new iteration context.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_setInt64IterationContext(
UConstrainedFieldPosition* ucfpos,
int64_t context,
UErrorCode* ec);
/**
* Sets new values for the primary public getters.
*
* Intended to be used by FormattedValue implementations.
*
* It is up to the implementation to ensure that the user-requested
* constraints are satisfied. This method does not check!
*
* @param ucfpos The instance of UConstrainedFieldPosition.
* @param category The new field category.
* @param field The new field.
* @param start The new inclusive start index.
* @param limit The new exclusive end index.
* @param ec Set if an error occurs.
* @draft ICU 64
*/
U_DRAFT void U_EXPORT2
ucfpos_setState(
UConstrainedFieldPosition* ucfpos,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
UErrorCode* ec);
struct UFormattedValue;
/**
* An abstract formatted value: a string with associated field attributes.
* Many formatters format to types compatible with UFormattedValue.
*
* @draft ICU 64
*/
typedef struct UFormattedValue UFormattedValue;
/**
* Returns a pointer to the formatted string. The pointer is owned by the UFormattedValue. The
* return value is valid only as long as the UFormattedValue is present and unchanged in memory.
*
* The return value is NUL-terminated but could contain internal NULs.
*
* @param ufmtval
* The object containing the formatted string and attributes.
* @param pLength Output variable for the length of the string. Ignored if NULL.
* @param ec Set if an error occurs.
* @return A NUL-terminated char16 string owned by the UFormattedValue.
* @draft ICU 64
*/
U_DRAFT const UChar* U_EXPORT2
ufmtval_getString(
const UFormattedValue* ufmtval,
int32_t* pLength,
UErrorCode* ec);
/**
* Iterates over field positions in the UFormattedValue. This lets you determine the position
* of specific types of substrings, like a month or a decimal separator.
*
* To loop over all field positions:
*
* UConstrainedFieldPosition* ucfpos = ucfpos_open(ec);
* while (ufmtval_nextPosition(ufmtval, ucfpos, ec)) {
* // handle the field position; get information from ucfpos
* }
* ucfpos_close(ucfpos);
*
* @param ufmtval
* The object containing the formatted string and attributes.
* @param ucfpos
* The object used for iteration state; can provide constraints to iterate over only
* one specific category or field;
* see ucfpos_constrainCategory
* and ucfpos_constrainField.
* @param ec Set if an error occurs.
* @return TRUE if another position was found; FALSE otherwise.
* @draft ICU 64
*/
U_DRAFT UBool U_EXPORT2
ufmtval_nextPosition(
const UFormattedValue* ufmtval,
UConstrainedFieldPosition* ucfpos,
UErrorCode* ec);
#if U_SHOW_CPLUSPLUS_API
U_NAMESPACE_BEGIN
/**
* \class LocalUConstrainedFieldPositionPointer
* "Smart pointer" class; closes a UConstrainedFieldPosition via ucfpos_close().
* For most methods see the LocalPointerBase base class.
*
* Usage:
*
* LocalUConstrainedFieldPositionPointer ucfpos(ucfpos_open(ec));
* // no need to explicitly call ucfpos_close()
*
* @draft ICU 64
*/
U_DEFINE_LOCAL_OPEN_POINTER(LocalUConstrainedFieldPositionPointer,
UConstrainedFieldPosition,
ucfpos_close);
U_NAMESPACE_END
#endif // U_SHOW_CPLUSPLUS_API
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif // __UFORMATTEDVALUE_H__

17
icu4c/source/i18n/unicode/unumberformatter.h
View file

@ -9,6 +9,7 @@
#include "unicode/ufieldpositer.h"
#include "unicode/umisc.h"
#include "unicode/uformattedvalue.h"
/**
@ -531,6 +532,22 @@ unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32
UFormattedNumber* uresult, UErrorCode* ec);
/**
* Returns a representation of a UFormattedNumber as a UFormattedValue, which can be
* subsequently passed to any API requiring that type.
*
* The returned object is owned by the UFormattedNumber and is valid only as long as the
* UFormattedNumber is present and unchanged in memory.
*
* @param uresult The object containing the formatted number.
* @param ec Set if an error occurs.
* @return A representation of the given UFormattedNumber as a UFormattedValue.
* @draft ICU 64
*/
U_DRAFT const UFormattedValue* U_EXPORT2
unumf_resultAsFormattedValue(const UFormattedNumber* uresult, UErrorCode* ec);
/**
* Extracts the result number string out of a UFormattedNumber to a UChar buffer if possible.
* If bufferCapacity is greater than the required length, a terminating NUL is written.

2
icu4c/source/test/cintltst/Makefile.in
View file

@ -55,7 +55,7 @@ hpmufn.o tracetst.o reapits.o uregiontest.o ulistfmttest.o\
utexttst.o ucsdetst.o spooftest.o \
cbiditransformtst.o \
cgendtst.o \
unumberformattertst.o
unumberformattertst.o uformattedvaluetst.o
DEPS = $(OBJECTS:.o=.d)

2
icu4c/source/test/cintltst/calltest.c
View file

@ -45,7 +45,6 @@ void addUSpoofTest(TestNode** root);
#if !UCONFIG_NO_FORMATTING
void addGendInfoForTest(TestNode** root);
#endif
void addUNumberFormatterTest(TestNode** root);
void addAllTests(TestNode** root)
{
@ -89,6 +88,5 @@ void addAllTests(TestNode** root)
addPUtilTest(root);
#if !UCONFIG_NO_FORMATTING
addGendInfoForTest(root);
addUNumberFormatterTest(root);
#endif
}

4
icu4c/source/test/cintltst/cformtst.c
View file

@ -39,6 +39,8 @@ void addCurrencyTest(TestNode**);
void addPluralRulesTest(TestNode**);
void addURegionTest(TestNode** root);
void addUListFmtTest(TestNode** root);
void addUNumberFormatterTest(TestNode** root);
void addUFormattedValueTest(TestNode** root);
void addFormatTest(TestNode** root);
@ -61,6 +63,8 @@ void addFormatTest(TestNode** root)
addPluralRulesTest(root);
addURegionTest(root);
addUListFmtTest(root);
addUNumberFormatterTest(root);
addUFormattedValueTest(root);
}
/*Internal functions used*/

13
icu4c/source/test/cintltst/cformtst.h
View file

@ -25,11 +25,24 @@
#include "cintltst.h"
#include "unicode/udat.h"
#include "unicode/uformattedvalue.h"
/* Internal fucntion used by all the test format files */
UChar* myDateFormat(UDateFormat *dat, UDate d);
// The following is implemented in uformattedvaluetest.c
// TODO: When needed, add overload with a different category for each position
void checkFormattedValue(
const char* message,
const UFormattedValue* fv,
const UChar* expectedString,
UFieldCategory expectedCategory,
const UFieldPosition* expectedFieldPositions,
int32_t expectedFieldPositionsLength);
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif

1
icu4c/source/test/cintltst/cintltst.vcxproj
View file

@ -243,6 +243,7 @@
<ClCompile Include="uregiontest.c" />
<ClCompile Include="ulistfmttest.c" />
<ClCompile Include="unumberformattertst.c" />
<ClCompile Include="uformattedvaluetst.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="cbiditst.h" />

3
icu4c/source/test/cintltst/cintltst.vcxproj.filters
View file

@ -222,6 +222,9 @@
<ClInclude Include="unumberformattertst.c">
<Filter>formatting</Filter>
</ClInclude>
<ClInclude Include="uformattedvaluetst.c">
<Filter>formatting</Filter>
</ClInclude>
<ClCompile Include="cldrtest.c">
<Filter>locales &amp; resources</Filter>
</ClCompile>

192
icu4c/source/test/cintltst/uformattedvaluetst.c Normal file
View file

@ -0,0 +1,192 @@
// © 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
#include "unicode/uformattedvalue.h"
#include "unicode/unum.h"
#include "unicode/ustring.h"
#include "cformtst.h"
#include "cintltst.h"
#include "cmemory.h"
#include "cstring.h"
#include "uassert.h"
static void TestBasic(void);
static void TestSetters(void);
static void AssertAllPartsEqual(
const char* messagePrefix,
const UConstrainedFieldPosition* ucfpos,
UCFPosConstraintType constraint,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
int64_t context);
void addUFormattedValueTest(TestNode** root);
#define TESTCASE(x) addTest(root, &x, "tsformat/uformattedvalue/" #x)
void addUFormattedValueTest(TestNode** root) {
TESTCASE(TestBasic);
TESTCASE(TestSetters);
}
static void TestBasic() {
UErrorCode status = U_ZERO_ERROR;
UConstrainedFieldPosition* ucfpos = ucfpos_open(&status);
assertSuccess("opening ucfpos", &status);
assertTrue("ucfpos should not be null", ucfpos != NULL);
AssertAllPartsEqual(
"basic",
ucfpos,
UCFPOS_CONSTRAINT_NONE,
UFIELD_CATEGORY_UNDEFINED,
0,
0,
0,
0LL);
ucfpos_close(ucfpos);
}
void TestSetters() {
UErrorCode status = U_ZERO_ERROR;
UConstrainedFieldPosition* ucfpos = ucfpos_open(&status);
assertSuccess("opening ucfpos", &status);
assertTrue("ucfpos should not be null", ucfpos != NULL);
ucfpos_constrainCategory(ucfpos, UFIELD_CATEGORY_DATE, &status);
assertSuccess("setters 0", &status);
AssertAllPartsEqual(
"setters 0",
ucfpos,
UCFPOS_CONSTRAINT_CATEGORY,
UFIELD_CATEGORY_DATE,
0,
0,
0,
0LL);
ucfpos_constrainField(ucfpos, UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD, &status);
assertSuccess("setters 1", &status);
AssertAllPartsEqual(
"setters 1",
ucfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
0,
0,
0LL);
ucfpos_setInt64IterationContext(ucfpos, 42424242424242LL, &status);
assertSuccess("setters 2", &status);
AssertAllPartsEqual(
"setters 2",
ucfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
0,
0,
42424242424242LL);
ucfpos_setState(ucfpos, UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD, 5, 10, &status);
assertSuccess("setters 3", &status);
AssertAllPartsEqual(
"setters 3",
ucfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
5,
10,
42424242424242LL);
ucfpos_reset(ucfpos, &status);
assertSuccess("setters 4", &status);
AssertAllPartsEqual(
"setters 4",
ucfpos,
UCFPOS_CONSTRAINT_NONE,
UFIELD_CATEGORY_UNDEFINED,
0,
0,
0,
0LL);
ucfpos_close(ucfpos);
}
static void AssertAllPartsEqual(
const char* messagePrefix,
const UConstrainedFieldPosition* ucfpos,
UCFPosConstraintType constraint,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
int64_t context) {
UErrorCode status = U_ZERO_ERROR;
char message[256];
uprv_strncpy(message, messagePrefix, 256);
int32_t prefixEnd = uprv_strlen(messagePrefix);
message[prefixEnd++] = ':';
message[prefixEnd++] = ' ';
U_ASSERT(prefixEnd < 256);
#define AAPE_MSG(suffix) (uprv_strncpy(message+prefixEnd, suffix, 256-prefixEnd)-prefixEnd)
UCFPosConstraintType _constraintType = ucfpos_getConstraintType(ucfpos, &status);
assertSuccess(AAPE_MSG("constraint"), &status);
assertIntEquals(AAPE_MSG("constraint"), constraint, _constraintType);
UFieldCategory _category = ucfpos_getCategory(ucfpos, &status);
assertSuccess(AAPE_MSG("_"), &status);
assertIntEquals(AAPE_MSG("category"), category, _category);
int32_t _field = ucfpos_getField(ucfpos, &status);
assertSuccess(AAPE_MSG("field"), &status);
assertIntEquals(AAPE_MSG("field"), field, _field);
int32_t _start, _limit;
ucfpos_getIndexes(ucfpos, &_start, &_limit, &status);
assertSuccess(AAPE_MSG("indexes"), &status);
assertIntEquals(AAPE_MSG("start"), start, _start);
assertIntEquals(AAPE_MSG("limit"), limit, _limit);
int64_t _context = ucfpos_getInt64IterationContext(ucfpos, &status);
assertSuccess(AAPE_MSG("context"), &status);
assertIntEquals(AAPE_MSG("context"), context, _context);
}
// Declared in cformtst.h
void checkFormattedValue(
const char* message,
const UFormattedValue* fv,
const UChar* expectedString,
UFieldCategory expectedCategory,
const UFieldPosition* expectedFieldPositions,
int32_t expectedFieldPositionsLength) {
UErrorCode status = U_ZERO_ERROR;
int32_t length;
const UChar* actualString = ufmtval_getString(fv, &length, &status);
assertSuccess(message, &status);
// The string is guaranteed to be NUL-terminated.
int32_t actualLength = u_strlen(actualString);
assertIntEquals(message, actualLength, length);
assertUEquals(message, expectedString, actualString);
}
#endif /* #if !UCONFIG_NO_FORMATTING */

47
icu4c/source/test/cintltst/unumberformattertst.c
View file

@ -12,6 +12,7 @@
#include "unicode/unumberformatter.h"
#include "unicode/umisc.h"
#include "unicode/unum.h"
#include "cformtst.h"
#include "cintltst.h"
#include "cmemory.h"
@ -21,12 +22,17 @@ static void TestSkeletonFormatToFields(void);
static void TestExampleCode(void);
static void TestFormattedValue(void);
void addUNumberFormatterTest(TestNode** root);
#define TESTCASE(x) addTest(root, &x, "tsformat/unumberformatter/" #x)
void addUNumberFormatterTest(TestNode** root) {
addTest(root, &TestSkeletonFormatToString, "unumberformatter/TestSkeletonFormatToString");
addTest(root, &TestSkeletonFormatToFields, "unumberformatter/TestSkeletonFormatToFields");
addTest(root, &TestExampleCode, "unumberformatter/TestExampleCode");
TESTCASE(TestSkeletonFormatToString);
TESTCASE(TestSkeletonFormatToFields);
TESTCASE(TestExampleCode);
TESTCASE(TestFormattedValue);
}
@ -188,4 +194,39 @@ static void TestExampleCode() {
}
static void TestFormattedValue() {
UErrorCode ec = U_ZERO_ERROR;
UNumberFormatter* uformatter = unumf_openForSkeletonAndLocale(
u".00 compact-short", -1, "en", &ec);
assertSuccessCheck("Should create without error", &ec, TRUE);
UFormattedNumber* uresult = unumf_openResult(&ec);
assertSuccess("Should create result without error", &ec);
unumf_formatInt(uformatter, 55000, uresult, &ec); // "55.00 K"
if (assertSuccessCheck("Should format without error", &ec, TRUE)) {
const UFormattedValue* fv = unumf_resultAsFormattedValue(uresult, &ec);
assertSuccess("Should convert without error", &ec);
static const UFieldPosition expectedFieldPositions[] = {
// field, begin index, end index
{UNUM_GROUPING_SEPARATOR_FIELD, 2, 3},
{UNUM_GROUPING_SEPARATOR_FIELD, 6, 7},
{UNUM_INTEGER_FIELD, 0, 10},
{UNUM_GROUPING_SEPARATOR_FIELD, 13, 14},
{UNUM_GROUPING_SEPARATOR_FIELD, 17, 18},
{UNUM_INTEGER_FIELD, 11, 21}};
checkFormattedValue(
"FormattedNumber as FormattedValue",
fv,
u"55.00K",
UFIELD_CATEGORY_NUMBER,
expectedFieldPositions,
UPRV_LENGTHOF(expectedFieldPositions));
}
// cleanup:
unumf_closeResult(uresult);
unumf_close(uformatter);
}
#endif /* #if !UCONFIG_NO_FORMATTING */

6
icu4c/source/test/depstest/dependencies.txt
View file

@ -935,6 +935,7 @@ group: number_representation
resourcebundle
int_functions
ucase uniset_core
formatted_value
group: numberformatter
# ICU 60+ NumberFormatter API
@ -1032,6 +1033,11 @@ group: formattable_cnv
deps
formattable unistr_cnv conversion
group: formatted_value
formattedvalue.o
deps
platform
group: format
format.o fphdlimp.o fpositer.o ufieldpositer.o
deps

3
icu4c/source/test/intltest/Makefile.in
View file

@ -66,7 +66,8 @@ numbertest_affixutils.o numbertest_api.o numbertest_decimalquantity.o \
numbertest_modifiers.o numbertest_patternmodifier.o numbertest_patternstring.o \
numbertest_stringbuilder.o numbertest_stringsegment.o \
numbertest_parse.o numbertest_doubleconversion.o numbertest_skeletons.o \
static_unisets_test.o numfmtdatadriventest.o numbertest_range.o erarulestest.o
static_unisets_test.o numfmtdatadriventest.o numbertest_range.o erarulestest.o \
formattedvaluetest.o
DEPS = $(OBJECTS:.o=.d)

227
icu4c/source/test/intltest/formattedvaluetest.cpp Normal file
View file

@ -0,0 +1,227 @@
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include <set>
#include "unicode/formattedvalue.h"
#include "unicode/unum.h"
#include "intltest.h"
#include "itformat.h"
class FormattedValueTest : public IntlTest {
public:
void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
private:
void testBasic();
void testSetters();
void testLocalPointer();
void assertAllPartsEqual(
UnicodeString messagePrefix,
const ConstrainedFieldPosition& cfpos,
UCFPosConstraintType constraint,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
int64_t context);
};
void FormattedValueTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char *) {
if (exec) {
logln("TestSuite FormattedValueTest: ");
}
TESTCASE_AUTO_BEGIN;
TESTCASE_AUTO(testBasic);
TESTCASE_AUTO(testSetters);
TESTCASE_AUTO(testLocalPointer);
TESTCASE_AUTO_END;
}
void FormattedValueTest::testBasic() {
IcuTestErrorCode status(*this, "testBasic");
ConstrainedFieldPosition cfpos;
assertAllPartsEqual(
u"basic",
cfpos,
UCFPOS_CONSTRAINT_NONE,
UFIELD_CATEGORY_UNDEFINED,
0,
0,
0,
0LL);
}
void FormattedValueTest::testSetters() {
IcuTestErrorCode status(*this, "testSetters");
ConstrainedFieldPosition cfpos;
cfpos.constrainCategory(UFIELD_CATEGORY_DATE);
assertAllPartsEqual(
u"setters 0",
cfpos,
UCFPOS_CONSTRAINT_CATEGORY,
UFIELD_CATEGORY_DATE,
0,
0,
0,
0LL);
cfpos.constrainField(UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD);
assertAllPartsEqual(
u"setters 1",
cfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
0,
0,
0LL);
cfpos.setInt64IterationContext(42424242424242LL);
assertAllPartsEqual(
u"setters 2",
cfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
0,
0,
42424242424242LL);
cfpos.setState(UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD, 5, 10);
assertAllPartsEqual(
u"setters 3",
cfpos,
UCFPOS_CONSTRAINT_FIELD,
UFIELD_CATEGORY_NUMBER,
UNUM_COMPACT_FIELD,
5,
10,
42424242424242LL);
cfpos.reset();
assertAllPartsEqual(
u"setters 4",
cfpos,
UCFPOS_CONSTRAINT_NONE,
UFIELD_CATEGORY_UNDEFINED,
0,
0,
0,
0LL);
}
void FormattedValueTest::testLocalPointer() {
UErrorCode status = U_ZERO_ERROR;
LocalUConstrainedFieldPositionPointer ucfpos(ucfpos_open(&status));
assertSuccess("Openining LocalUConstrainedFieldPositionPointer", status);
assertEquals(u"Test that object is valid",
UCFPOS_CONSTRAINT_NONE,
ucfpos_getConstraintType(ucfpos.getAlias(), &status));
assertSuccess("Using LocalUConstrainedFieldPositionPointer", status);
}
void FormattedValueTest::assertAllPartsEqual(
UnicodeString messagePrefix,
const ConstrainedFieldPosition& cfpos,
UCFPosConstraintType constraint,
UFieldCategory category,
int32_t field,
int32_t start,
int32_t limit,
int64_t context) {
assertEquals(messagePrefix + u": constraint",
constraint, cfpos.getConstraintType());
assertEquals(messagePrefix + u": category",
category, cfpos.getCategory());
assertEquals(messagePrefix + u": field",
field, cfpos.getField());
assertEquals(messagePrefix + u": start",
start, cfpos.getStart());
assertEquals(messagePrefix + u": limit",
limit, cfpos.getLimit());
assertEquals(messagePrefix + u": context",
context, cfpos.getInt64IterationContext());
}
void IntlTestWithFieldPosition::checkFormattedValue(
const char16_t* message,
const FormattedValue& fv,
UnicodeString expectedString,
UFieldCategory expectedCategory,
const UFieldPosition* expectedFieldPositions,
int32_t length) {
IcuTestErrorCode status(*this, "checkFormattedValue");
UnicodeString baseMessage = UnicodeString(message) + u": " + fv.toString(status) + u": ";
// Check string values
assertEquals(baseMessage + u"string", expectedString, fv.toString(status));
assertEquals(baseMessage + u"temp string", expectedString, fv.toTempString(status));
// The temp string is guaranteed to be NUL-terminated
UnicodeString readOnlyAlias = fv.toTempString(status);
assertEquals(baseMessage + u"NUL-terminated",
0, readOnlyAlias.getBuffer()[readOnlyAlias.length()]);
// Check nextPosition over all fields
ConstrainedFieldPosition cfpos;
cfpos.constrainCategory(expectedCategory);
for (int32_t i = 0; i < length; i++) {
assertTrue(baseMessage + i, fv.nextPosition(cfpos, status));
int32_t expectedField = expectedFieldPositions[i].field;
int32_t expectedStart = expectedFieldPositions[i].beginIndex;
int32_t expectedLimit = expectedFieldPositions[i].endIndex;
assertEquals(baseMessage + u"category " + Int64ToUnicodeString(i),
expectedCategory, cfpos.getCategory());
assertEquals(baseMessage + u"field " + Int64ToUnicodeString(i),
expectedField, cfpos.getField());
assertEquals(baseMessage + u"start " + Int64ToUnicodeString(i),
expectedStart, cfpos.getStart());
assertEquals(baseMessage + u"limit " + Int64ToUnicodeString(i),
expectedLimit, cfpos.getLimit());
}
assertFalse(baseMessage + u"after loop", fv.nextPosition(cfpos, status));
// Check nextPosition constrained over each field one at a time
std::set<int32_t> uniqueFields;
for (int32_t i = 0; i < length; i++) {
uniqueFields.insert(expectedFieldPositions[i].field);
}
for (int32_t field : uniqueFields) {
cfpos.reset();
cfpos.constrainField(expectedCategory, field);
for (int32_t i = 0; i < length; i++) {
if (expectedFieldPositions[i].field != field) {
continue;
}
assertTrue(baseMessage + i, fv.nextPosition(cfpos, status));
int32_t expectedField = expectedFieldPositions[i].field;
int32_t expectedStart = expectedFieldPositions[i].beginIndex;
int32_t expectedLimit = expectedFieldPositions[i].endIndex;
assertEquals(baseMessage + u"category " + Int64ToUnicodeString(i),
expectedCategory, cfpos.getCategory());
assertEquals(baseMessage + u"field " + Int64ToUnicodeString(i),
expectedField, cfpos.getField());
assertEquals(baseMessage + u"start " + Int64ToUnicodeString(i),
expectedStart, cfpos.getStart());
assertEquals(baseMessage + u"limit " + Int64ToUnicodeString(i),
expectedLimit, cfpos.getLimit());
}
assertFalse(baseMessage + u"after loop", fv.nextPosition(cfpos, status));
}
}
extern IntlTest *createFormattedValueTest() {
return new FormattedValueTest();
}
#endif /* !UCONFIG_NO_FORMATTING */

1
icu4c/source/test/intltest/intltest.vcxproj
View file

@ -363,6 +363,7 @@
<ClCompile Include="csdetest.cpp" />
<ClCompile Include="bidiconf.cpp" />
<ClCompile Include="listformattertest.cpp" />
<ClCompile Include="formattedvaluetest.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="colldata.h" />

3
icu4c/source/test/intltest/intltest.vcxproj.filters
View file

@ -538,6 +538,9 @@
<ClCompile Include="erarulestest.cpp">
<Filter>formatting</Filter>
</ClCompile>
<ClCompile Include="formattedvaluetest.cpp">
<Filter>formatting</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="itrbbi.h">

10
icu4c/source/test/intltest/itformat.cpp
View file

@ -71,6 +71,7 @@ extern IntlTest *createTimeUnitTest();
extern IntlTest *createMeasureFormatTest();
extern IntlTest *createNumberFormatSpecificationTest();
extern IntlTest *createScientificNumberFormatterTest();
extern IntlTest *createFormattedValueTest();
#define TESTCLASS(id, TestClass) \
@ -217,6 +218,15 @@ void IntlTestFormat::runIndexedTest( int32_t index, UBool exec, const char* &nam
TESTCLASS(50,NumberFormatDataDrivenTest);
TESTCLASS(51,NumberTest);
TESTCLASS(52,EraRulesTest);
case 53:
name = "FormattedValueTest";
if (exec) {
logln("FormattedValueTest test---");
logln((UnicodeString)"");
LocalPointer<IntlTest> test(createFormattedValueTest());
callTest(*test, par);
}
break;
default: name = ""; break; //needed to end loop
}
if (exec) {

15
icu4c/source/test/intltest/itformat.h
View file

@ -17,6 +17,7 @@
#if !UCONFIG_NO_FORMATTING
#include "unicode/formattedvalue.h"
#include "intltest.h"
@ -24,6 +25,20 @@ class IntlTestFormat: public IntlTest {
void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL );
};
class IntlTestWithFieldPosition : public IntlTest {
public:
// TODO: When needed, add overload with a different category for each position
void checkFormattedValue(
const char16_t* message,
const FormattedValue& fv,
UnicodeString expectedString,
UFieldCategory expectedCategory,
const UFieldPosition* expectedFieldPositions,
int32_t length);
};
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif

15
icu4c/source/test/intltest/numbertest.h
View file

@ -8,6 +8,7 @@
#include "number_stringbuilder.h"
#include "intltest.h"
#include "itformat.h"
#include "number_affixutils.h"
#include "numparse_stringsegment.h"
#include "numrange_impl.h"
@ -43,7 +44,7 @@ class AffixUtilsTest : public IntlTest {
UErrorCode &status);
};
class NumberFormatterApiTest : public IntlTest {
class NumberFormatterApiTest : public IntlTestWithFieldPosition {
public:
NumberFormatterApiTest();
NumberFormatterApiTest(UErrorCode &status);
@ -119,8 +120,11 @@ class NumberFormatterApiTest : public IntlTest {
void assertUndefinedSkeleton(const UnlocalizedNumberFormatter& f);
void assertFieldPositions(const char16_t* message, const FormattedNumber& formattedNumber,
const UFieldPosition* expectedFieldPositions, int32_t length);
void assertNumberFieldPositions(
const char16_t* message,
const FormattedNumber& formattedNumber,
const UFieldPosition* expectedFieldPositions,
int32_t length);
};
class DecimalQuantityTest : public IntlTest {
@ -253,7 +257,7 @@ class NumberSkeletonTest : public IntlTest {
void expectedErrorSkeleton(const char16_t** cases, int32_t casesLen);
};
class NumberRangeFormatterTest : public IntlTest {
class NumberRangeFormatterTest : public IntlTestWithFieldPosition {
public:
NumberRangeFormatterTest();
NumberRangeFormatterTest(UErrorCode &status);
@ -264,6 +268,7 @@ class NumberRangeFormatterTest : public IntlTest {
void testIdentity();
void testDifferentFormatters();
void testPlurals();
void testFieldPositions();
void testCopyMove();
void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par = 0);
@ -293,7 +298,7 @@ class NumberRangeFormatterTest : public IntlTest {
const char16_t* expected_50K_50K,
const char16_t* expected_50K_50M);
void assertFormattedRangeEquals(
FormattedNumberRange assertFormattedRangeEquals(
const char16_t* message,
const LocalizedNumberRangeFormatter& l,
double first,

76
icu4c/source/test/intltest/numbertest_api.cpp
View file

@ -2188,11 +2188,11 @@ void NumberFormatterApiTest::fieldPositionLogic() {
{UNUM_DECIMAL_SEPARATOR_FIELD, 14, 15},
{UNUM_FRACTION_FIELD, 15, 17}};
assertFieldPositions(
assertNumberFieldPositions(
message,
fmtd,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
// Test the iteration functionality of nextFieldPosition
FieldPosition actual = {UNUM_GROUPING_SEPARATOR_FIELD};
@ -2236,11 +2236,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 0, 2},
{UNUM_MEASURE_UNIT_FIELD, 2, 4}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2257,11 +2257,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_INTEGER_FIELD, 0, 2},
// coverage for old enum:
{DecimalFormat::kMeasureUnitField, 2, 6}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2278,11 +2278,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_INTEGER_FIELD, 0, 2},
// note: field starts after the space
{UNUM_MEASURE_UNIT_FIELD, 3, 9}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2299,11 +2299,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_MEASURE_UNIT_FIELD, 0, 11},
{UNUM_INTEGER_FIELD, 12, 14},
{UNUM_MEASURE_UNIT_FIELD, 15, 19}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2320,11 +2320,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_INTEGER_FIELD, 0, 2},
// Should trim leading/trailing spaces, but not inner spaces:
{UNUM_MEASURE_UNIT_FIELD, 3, 7}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2343,11 +2343,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 1, 3},
{UNUM_MEASURE_UNIT_FIELD, 4, 5}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2363,11 +2363,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 0, 2},
{UNUM_COMPACT_FIELD, 2, 3}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2383,11 +2383,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 0, 2},
{UNUM_COMPACT_FIELD, 3, 11}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2403,11 +2403,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 0, 1},
{UNUM_COMPACT_FIELD, 2, 9}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2423,11 +2423,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 1, 2},
{UNUM_COMPACT_FIELD, 3, 6}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2444,11 +2444,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_INTEGER_FIELD, 0, 2},
{UNUM_COMPACT_FIELD, 3, 8},
{UNUM_CURRENCY_FIELD, 9, 12}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
{
@ -2467,11 +2467,11 @@ void NumberFormatterApiTest::fieldPositionCoverage() {
{UNUM_INTEGER_FIELD, 0, 2},
{UNUM_COMPACT_FIELD, 3, 11},
{UNUM_MEASURE_UNIT_FIELD, 12, 18}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions,
sizeof(expectedFieldPositions)/sizeof(*expectedFieldPositions));
UPRV_LENGTHOF(expectedFieldPositions));
}
}
@ -2882,10 +2882,30 @@ void NumberFormatterApiTest::assertUndefinedSkeleton(const UnlocalizedNumberForm
status);
}
void NumberFormatterApiTest::assertFieldPositions(
void NumberFormatterApiTest::assertNumberFieldPositions(
const char16_t* message, const FormattedNumber& formattedNumber,
const UFieldPosition* expectedFieldPositions, int32_t length) {
IcuTestErrorCode status(*this, "assertFieldPositions");
IcuTestErrorCode status(*this, "assertNumberFieldPositions");
// Check FormattedValue functions
checkFormattedValue(
message,
static_cast<const FormattedValue&>(formattedNumber),
formattedNumber.toString(status),
UFIELD_CATEGORY_NUMBER,
expectedFieldPositions,
length);
// Check no field positions in an unrelated category
checkFormattedValue(
message,
static_cast<const FormattedValue&>(formattedNumber),
formattedNumber.toString(status),
UFIELD_CATEGORY_DATE,
nullptr,
0);
// Check FormattedNumber-specific functions
UnicodeString baseMessage = UnicodeString(message) + u": " + formattedNumber.toString(status) + u": ";
FieldPositionIterator fpi;
formattedNumber.getAllFieldPositions(fpi, status);

64
icu4c/source/test/intltest/numbertest_range.cpp
View file

@ -48,6 +48,7 @@ void NumberRangeFormatterTest::runIndexedTest(int32_t index, UBool exec, const c
TESTCASE_AUTO(testIdentity);
TESTCASE_AUTO(testDifferentFormatters);
TESTCASE_AUTO(testPlurals);
TESTCASE_AUTO(testFieldPositions);
TESTCASE_AUTO(testCopyMove);
TESTCASE_AUTO_END;
}
@ -723,6 +724,63 @@ void NumberRangeFormatterTest::testPlurals() {
}
}
void NumberRangeFormatterTest::testFieldPositions() {
{
const char16_t* message = u"Field position test 1";
const char16_t* expectedString = u"3K – 5K m";
FormattedNumberRange result = assertFormattedRangeEquals(
message,
NumberRangeFormatter::with()
.numberFormatterBoth(NumberFormatter::with()
.unit(METER)
.notation(Notation::compactShort()))
.locale("en-us"),
3000,
5000,
expectedString);
static const UFieldPosition expectedFieldPositions[] = {
// field, begin index, end index
{UNUM_INTEGER_FIELD, 0, 1},
{UNUM_COMPACT_FIELD, 1, 2},
{UNUM_INTEGER_FIELD, 5, 6},
{UNUM_COMPACT_FIELD, 6, 7},
{UNUM_MEASURE_UNIT_FIELD, 8, 9}};
checkFormattedValue(
message,
result,
expectedString,
UFIELD_CATEGORY_NUMBER,
expectedFieldPositions,
UPRV_LENGTHOF(expectedFieldPositions));
}
{
const char16_t* message = u"Field position test 2";
const char16_t* expectedString = u"87,654,321–98,765,432";
FormattedNumberRange result = assertFormattedRangeEquals(
message,
NumberRangeFormatter::withLocale("en-us"),
87654321,
98765432,
expectedString);
static const UFieldPosition expectedFieldPositions[] = {
// field, begin index, end index
{UNUM_GROUPING_SEPARATOR_FIELD, 2, 3},
{UNUM_GROUPING_SEPARATOR_FIELD, 6, 7},
{UNUM_INTEGER_FIELD, 0, 10},
{UNUM_GROUPING_SEPARATOR_FIELD, 13, 14},
{UNUM_GROUPING_SEPARATOR_FIELD, 17, 18},
{UNUM_INTEGER_FIELD, 11, 21}};
checkFormattedValue(
message,
result,
expectedString,
UFIELD_CATEGORY_NUMBER,
expectedFieldPositions,
UPRV_LENGTHOF(expectedFieldPositions));
}
}
void NumberRangeFormatterTest::testCopyMove() {
IcuTestErrorCode status(*this, "testCopyMove");
@ -792,7 +850,7 @@ void NumberRangeFormatterTest::assertFormatRange(
assertFormattedRangeEquals(message, l, 5e3, 5e6, expected_50K_50M);
}
void NumberRangeFormatterTest::assertFormattedRangeEquals(
FormattedNumberRange NumberRangeFormatterTest::assertFormattedRangeEquals(
const char16_t* message,
const LocalizedNumberRangeFormatter& l,
double first,
@ -801,8 +859,10 @@ void NumberRangeFormatterTest::assertFormattedRangeEquals(
IcuTestErrorCode status(*this, "assertFormattedRangeEquals");
UnicodeString fullMessage = UnicodeString(message) + u": " + DoubleToUnicodeString(first) + u", " + DoubleToUnicodeString(second);
status.setScope(fullMessage);
UnicodeString actual = l.formatFormattableRange(first, second, status).toString(status);
FormattedNumberRange fnr = l.formatFormattableRange(first, second, status);
UnicodeString actual = fnr.toString(status);
assertEquals(fullMessage, expected, actual);
return fnr;
}

202
icu4j/main/classes/core/src/com/ibm/icu/impl/number/NumberStringBuilder.java
View file

@ -10,6 +10,8 @@ import java.util.HashMap;
import java.util.Map;
import com.ibm.icu.impl.StaticUnicodeSets;
import com.ibm.icu.text.ConstrainedFieldPosition;
import com.ibm.icu.text.ConstrainedFieldPosition.ConstraintType;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.NumberFormat.Field;
import com.ibm.icu.text.UnicodeSet;
@ -364,17 +366,27 @@ public class NumberStringBuilder implements CharSequence {
return chars.length;
}
/** Note: this returns a NumberStringBuilder. Do not return publicly. */
@Override
@Deprecated
public CharSequence subSequence(int start, int end) {
if (start < 0 || end > length || end < start) {
throw new IndexOutOfBoundsException();
}
assert start >= 0;
assert end <= length;
assert end >= start;
NumberStringBuilder other = new NumberStringBuilder(this);
other.zero = zero + start;
other.length = end - start;
return other;
}
/** Use this instead of subSequence if returning publicly. */
public String subString(int start, int end) {
if (start < 0 || end > length || end < start) {
throw new IndexOutOfBoundsException();
}
return new String(chars, start + zero, end - start);
}
/**
* Returns the string represented by the characters in this string builder.
*
@ -400,6 +412,8 @@ public class NumberStringBuilder implements CharSequence {
fieldToDebugChar.put(NumberFormat.Field.PERCENT, '%');
fieldToDebugChar.put(NumberFormat.Field.PERMILLE, '‰');
fieldToDebugChar.put(NumberFormat.Field.CURRENCY, '$');
fieldToDebugChar.put(NumberFormat.Field.MEASURE_UNIT, 'u');
fieldToDebugChar.put(NumberFormat.Field.COMPACT, 'C');
}
/**
@ -483,13 +497,6 @@ public class NumberStringBuilder implements CharSequence {
throw new UnsupportedOperationException("Don't call #hashCode() or #equals() on a mutable.");
}
/**
* Populates the given {@link FieldPosition} based on this string builder.
*
* @param fp
* The FieldPosition to populate.
* @return true if the field was found; false if it was not found.
*/
public boolean nextFieldPosition(FieldPosition fp) {
java.text.Format.Field rawField = fp.getFieldAttribute();
@ -511,99 +518,120 @@ public class NumberStringBuilder implements CharSequence {
+ rawField.getClass().toString());
}
NumberFormat.Field field = (NumberFormat.Field) rawField;
ConstrainedFieldPosition cfpos = new ConstrainedFieldPosition();
cfpos.constrainField(rawField);
cfpos.setState(rawField, null, fp.getBeginIndex(), fp.getEndIndex());
if (nextPosition(cfpos)) {
fp.setBeginIndex(cfpos.getStart());
fp.setEndIndex(cfpos.getLimit());
return true;
}
boolean seenStart = false;
int fractionStart = -1;
int startIndex = fp.getEndIndex();
for (int i = zero + startIndex; i <= zero + length; i++) {
Field _field = (i < zero + length) ? fields[i] : null;
if (seenStart && field != _field) {
// Special case: GROUPING_SEPARATOR counts as an INTEGER.
if (field == NumberFormat.Field.INTEGER
&& _field == NumberFormat.Field.GROUPING_SEPARATOR) {
continue;
}
fp.setEndIndex(i - zero);
// Trim ignorables (whitespace, etc.) from the edge of the field.
if (trimFieldPosition(fp)) {
// Special case: fraction should start after integer if fraction is not present
if (rawField == NumberFormat.Field.FRACTION && fp.getEndIndex() == 0) {
boolean inside = false;
int i = zero;
for (; i < zero + length; i++) {
if (isIntOrGroup(fields[i]) || fields[i] == NumberFormat.Field.DECIMAL_SEPARATOR) {
inside = true;
} else if (inside) {
break;
}
// This position was all ignorables; continue to the next position.
seenStart = false;
} else if (!seenStart && field == _field) {
fp.setBeginIndex(i - zero);
seenStart = true;
}
if (_field == NumberFormat.Field.INTEGER || _field == NumberFormat.Field.DECIMAL_SEPARATOR) {
fractionStart = i - zero + 1;
}
fp.setBeginIndex(i - zero);
fp.setEndIndex(i - zero);
}
// Backwards compatibility: FRACTION needs to start after INTEGER if empty.
// Do not return that a field was found, though, since there is not actually a fraction part.
if (field == NumberFormat.Field.FRACTION && !seenStart && fractionStart != -1) {
fp.setBeginIndex(fractionStart);
fp.setEndIndex(fractionStart);
}
return seenStart;
return false;
}
public AttributedCharacterIterator toCharacterIterator() {
ConstrainedFieldPosition cfpos = new ConstrainedFieldPosition();
AttributedString as = new AttributedString(toString());
Field current = null;
int currentStart = -1;
for (int i = 0; i < length; i++) {
Field field = fields[i + zero];
if (current == NumberFormat.Field.INTEGER
&& field == NumberFormat.Field.GROUPING_SEPARATOR) {
// Special case: GROUPING_SEPARATOR counts as an INTEGER.
// TODO(ICU-13064): Grouping separator can be more than 1 code unit.
as.addAttribute(NumberFormat.Field.GROUPING_SEPARATOR,
NumberFormat.Field.GROUPING_SEPARATOR,
i,
i + 1);
} else if (current != field) {
if (current != null) {
FieldPosition fp = new FieldPosition(null);
fp.setBeginIndex(currentStart);
fp.setEndIndex(i);
if (trimFieldPosition(fp)) {
as.addAttribute(current, current, fp.getBeginIndex(), fp.getEndIndex());
}
}
current = field;
currentStart = i;
}
while (this.nextPosition(cfpos)) {
// Backwards compatibility: field value = field
as.addAttribute(cfpos.getField(), cfpos.getField(), cfpos.getStart(), cfpos.getLimit());
}
if (current != null) {
FieldPosition fp = new FieldPosition(null);
fp.setBeginIndex(currentStart);
fp.setEndIndex(length);
if (trimFieldPosition(fp)) {
as.addAttribute(current, current, fp.getBeginIndex(), fp.getEndIndex());
}
}
return as.getIterator();
}
private boolean trimFieldPosition(FieldPosition fp) {
// Trim ignorables from the back
int endIgnorablesIndex = StaticUnicodeSets.get(StaticUnicodeSets.Key.DEFAULT_IGNORABLES)
.spanBack(this, fp.getEndIndex(), UnicodeSet.SpanCondition.CONTAINED);
// Check if the entire segment is ignorables
if (endIgnorablesIndex <= fp.getBeginIndex()) {
public boolean nextPosition(ConstrainedFieldPosition cfpos) {
if (cfpos.getConstraintType() == ConstraintType.CLASS
&& !cfpos.getClassConstraint().isAssignableFrom(NumberFormat.Field.class)) {
return false;
}
fp.setEndIndex(endIgnorablesIndex);
// Trim ignorables from the front
int startIgnorablesIndex = StaticUnicodeSets.get(StaticUnicodeSets.Key.DEFAULT_IGNORABLES)
.span(this, fp.getBeginIndex(), UnicodeSet.SpanCondition.CONTAINED);
fp.setBeginIndex(startIgnorablesIndex);
return true;
boolean isSearchingForField = (cfpos.getConstraintType() == ConstraintType.FIELD);
int fieldStart = -1;
Field currField = null;
for (int i = zero + cfpos.getLimit(); i <= zero + length; i++) {
Field _field = (i < zero + length) ? fields[i] : null;
// Case 1: currently scanning a field.
if (currField != null) {
if (currField != _field) {
int end = i - zero;
// Grouping separators can be whitespace; don't throw them out!
if (currField != NumberFormat.Field.GROUPING_SEPARATOR) {
end = trimBack(end);
}
if (end <= fieldStart) {
// Entire field position is ignorable; skip.
fieldStart = -1;
currField = null;
i--; // look at this index again
continue;
}
int start = fieldStart;
if (currField != NumberFormat.Field.GROUPING_SEPARATOR) {
start = trimFront(start);
}
cfpos.setState(currField, null, start, end);
return true;
}
continue;
}
// Special case: coalesce the INTEGER if we are pointing at the end of the INTEGER.
if ((!isSearchingForField || cfpos.getField() == NumberFormat.Field.INTEGER)
&& i > zero
&& i - zero > cfpos.getLimit() // don't return the same field twice in a row
&& isIntOrGroup(fields[i - 1])
&& !isIntOrGroup(_field)) {
int j = i - 1;
for (; j >= zero && isIntOrGroup(fields[j]); j--) {}
cfpos.setState(NumberFormat.Field.INTEGER, null, j - zero + 1, i - zero);
return true;
}
// Special case: skip over INTEGER; will be coalesced later.
if (_field == NumberFormat.Field.INTEGER) {
_field = null;
}
// Case 2: no field starting at this position.
if (_field == null) {
continue;
}
// Case 3: check for field starting at this position
if (!isSearchingForField || cfpos.getField() == _field) {
fieldStart = i - zero;
currField = _field;
}
}
assert currField == null;
return false;
}
private static boolean isIntOrGroup(NumberFormat.Field field) {
return field == NumberFormat.Field.INTEGER || field == NumberFormat.Field.GROUPING_SEPARATOR;
}
private int trimBack(int limit) {
return StaticUnicodeSets.get(StaticUnicodeSets.Key.DEFAULT_IGNORABLES)
.spanBack(this, limit, UnicodeSet.SpanCondition.CONTAINED);
}
private int trimFront(int start) {
return StaticUnicodeSets.get(StaticUnicodeSets.Key.DEFAULT_IGNORABLES)
.span(this, start, UnicodeSet.SpanCondition.CONTAINED);
}
}

77
icu4j/main/classes/core/src/com/ibm/icu/number/FormattedNumber.java
View file

@ -10,6 +10,8 @@ import java.util.Arrays;
import com.ibm.icu.impl.number.DecimalQuantity;
import com.ibm.icu.impl.number.NumberStringBuilder;
import com.ibm.icu.text.ConstrainedFieldPosition;
import com.ibm.icu.text.FormattedValue;
import com.ibm.icu.text.PluralRules.IFixedDecimal;
import com.ibm.icu.util.ICUUncheckedIOException;
@ -21,7 +23,7 @@ import com.ibm.icu.util.ICUUncheckedIOException;
* @provisional This API might change or be removed in a future release.
* @see NumberFormatter
*/
public class FormattedNumber {
public class FormattedNumber implements FormattedValue {
final NumberStringBuilder nsb;
final DecimalQuantity fq;
@ -31,12 +33,10 @@ public class FormattedNumber {
}
/**
* Creates a String representation of the the formatted number.
* {@inheritDoc}
*
* @return a String containing the localized number.
* @draft ICU 60
* @provisional This API might change or be removed in a future release.
* @see NumberFormatter
*/
@Override
public String toString() {
@ -44,21 +44,12 @@ public class FormattedNumber {
}
/**
* Append the formatted number to an Appendable, such as a StringBuilder. This may be slightly more
* efficient than creating a String.
* {@inheritDoc}
*
* <p>
* If an IOException occurs when appending to the Appendable, an unchecked
* {@link ICUUncheckedIOException} is thrown instead.
*
* @param appendable
* The Appendable to which to append the formatted number string.
* @return The same Appendable, for chaining.
* @draft ICU 60
* @provisional This API might change or be removed in a future release.
* @see Appendable
* @see NumberFormatter
*/
@Override
public <A extends Appendable> A appendTo(A appendable) {
try {
appendable.append(nsb);
@ -69,6 +60,50 @@ public class FormattedNumber {
return appendable;
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public char charAt(int index) {
return nsb.charAt(index);
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public int length() {
return nsb.length();
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public CharSequence subSequence(int start, int end) {
return nsb.subString(start, end);
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public boolean nextPosition(ConstrainedFieldPosition cfpos) {
return nsb.nextPosition(cfpos);
}
/**
* Determines the start (inclusive) and end (exclusive) indices of the next occurrence of the given
* <em>field</em> in the output string. This allows you to determine the locations of, for example,
@ -155,20 +190,12 @@ public class FormattedNumber {
}
/**
* Export the formatted number as an AttributedCharacterIterator. This allows you to determine which
* characters in the output string correspond to which <em>fields</em>, such as the integer part,
* fraction part, and sign.
* <p>
* If information on only one field is needed, use {@link #nextFieldPosition(FieldPosition)} instead.
* {@inheritDoc}
*
* @return An AttributedCharacterIterator, containing information on the field attributes of the
* number string.
* @draft ICU 62
* @provisional This API might change or be removed in a future release.
* @see com.ibm.icu.text.NumberFormat.Field
* @see AttributedCharacterIterator
* @see NumberFormatter
*/
@Override
public AttributedCharacterIterator toCharacterIterator() {
return nsb.toCharacterIterator();
}

77
icu4j/main/classes/core/src/com/ibm/icu/number/FormattedNumberRange.java
View file

@ -11,6 +11,8 @@ import java.util.Arrays;
import com.ibm.icu.impl.number.DecimalQuantity;
import com.ibm.icu.impl.number.NumberStringBuilder;
import com.ibm.icu.number.NumberRangeFormatter.RangeIdentityResult;
import com.ibm.icu.text.ConstrainedFieldPosition;
import com.ibm.icu.text.FormattedValue;
import com.ibm.icu.util.ICUUncheckedIOException;
/**
@ -22,7 +24,7 @@ import com.ibm.icu.util.ICUUncheckedIOException;
* @provisional This API might change or be removed in a future release.
* @see NumberRangeFormatter
*/
public class FormattedNumberRange {
public class FormattedNumberRange implements FormattedValue {
final NumberStringBuilder string;
final DecimalQuantity quantity1;
final DecimalQuantity quantity2;
@ -37,12 +39,10 @@ public class FormattedNumberRange {
}
/**
* Creates a String representation of the the formatted number range.
* {@inheritDoc}
*
* @return a String containing the localized number range.
* @draft ICU 63
* @provisional This API might change or be removed in a future release.
* @see NumberRangeFormatter
*/
@Override
public String toString() {
@ -50,21 +50,12 @@ public class FormattedNumberRange {
}
/**
* Append the formatted number range to an Appendable, such as a StringBuilder. This may be slightly more efficient
* than creating a String.
* {@inheritDoc}
*
* <p>
* If an IOException occurs when appending to the Appendable, an unchecked {@link ICUUncheckedIOException} is thrown
* instead.
*
* @param appendable
* The Appendable to which to append the formatted number range string.
* @return The same Appendable, for chaining.
* @draft ICU 63
* @provisional This API might change or be removed in a future release.
* @see Appendable
* @see NumberRangeFormatter
*/
@Override
public <A extends Appendable> A appendTo(A appendable) {
try {
appendable.append(string);
@ -75,6 +66,50 @@ public class FormattedNumberRange {
return appendable;
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public char charAt(int index) {
return string.charAt(index);
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public int length() {
return string.length();
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public CharSequence subSequence(int start, int end) {
return string.subString(start, end);
}
/**
* {@inheritDoc}
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public boolean nextPosition(ConstrainedFieldPosition cfpos) {
return string.nextPosition(cfpos);
}
/**
* Determines the start (inclusive) and end (exclusive) indices of the next occurrence of the given
* <em>field</em> in the output string. This allows you to determine the locations of, for example,
@ -109,20 +144,12 @@ public class FormattedNumberRange {
}
/**
* Export the formatted number range as an AttributedCharacterIterator. This allows you to determine which
* characters in the output string correspond to which <em>fields</em>, such as the integer part, fraction part, and
* sign.
* <p>
* If information on only one field is needed, use {@link #nextFieldPosition(FieldPosition)} instead.
* {@inheritDoc}
*
* @return An AttributedCharacterIterator, containing information on the field attributes of the number range
* string.
* @draft ICU 63
* @provisional This API might change or be removed in a future release.
* @see com.ibm.icu.text.NumberFormat.Field
* @see AttributedCharacterIterator
* @see NumberRangeFormatter
*/
@Override
public AttributedCharacterIterator toCharacterIterator() {
return string.toCharacterIterator();
}

320
icu4j/main/classes/core/src/com/ibm/icu/text/ConstrainedFieldPosition.java Normal file
View file

@ -0,0 +1,320 @@
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
package com.ibm.icu.text;
import java.text.Format.Field;
/**
* Represents a span of a string containing a given field.
*
* This class differs from FieldPosition in the following ways:
*
* 1. It has information on the field category.
* 2. It allows you to set constraints to use when iterating over field positions.
* 3. It is used for the newer FormattedValue APIs.
*
* @author sffc
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public class ConstrainedFieldPosition {
/**
* Represents the type of constraint for ConstrainedFieldPosition.
*
* Constraints are used to control the behavior of iteration in FormattedValue.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public enum ConstraintType {
/**
* Represents the lack of a constraint.
*
* This is the return value of {@link #getConstraintType}
* if no "constrain" methods were called.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
NONE,
/**
* Represents that the field class is constrained.
* Use {@link #getClassConstraint} to access the class.
*
* This is the return value of @link #getConstraintType}
* after {@link #constrainClass} is called.
*
* FormattedValue implementations should not change the field when this constraint is active.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
CLASS,
/**
* Represents that the field is constrained.
* Use {@link #getField} to access the field.
*
* This is the return value of @link #getConstraintType}
* after {@link #constrainField} is called.
*
* FormattedValue implementations should not change the field when this constraint is active.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
FIELD
};
private ConstraintType fConstraint;
private Class<?> fClassConstraint;
private Field fField;
private Object fValue;
private int fStart;
private int fLimit;
private long fContext;
/**
* Initializes a CategoryFieldPosition.
*
* By default, the CategoryFieldPosition has no iteration constraints.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public ConstrainedFieldPosition() {
reset();
}
/**
* Resets this ConstrainedFieldPosition to its initial state, as if it were newly created:
*
* - Removes any constraints that may have been set on the instance.
* - Resets the iteration position.
*
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public void reset() {
fConstraint = ConstraintType.NONE;
fClassConstraint = Object.class;
fField = null;
fValue = null;
fStart = 0;
fLimit = 0;
fContext = 0;
}
/**
* Sets a constraint on the field.
*
* When this instance of ConstrainedFieldPosition is passed to {@link FormattedValue#nextPosition}, positions are
* skipped unless they have the given category and field.
*
* Any previously set constraints are cleared.
*
* For example, to loop over all grouping separators:
*
* <pre>
* ConstrainedFieldPosition cfpos;
* cfpos.constrainField(NumberFormat.Field.GROUPING_SEPARATOR);
* while (fmtval.nextPosition(cfpos)) {
* // handle the grouping separator position
* }
* </pre>
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param field
* The field to fix when iterating.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public void constrainField(Field field) {
if (field == null) {
throw new IllegalArgumentException("Cannot constrain on null field");
}
fConstraint = ConstraintType.FIELD;
fClassConstraint = Object.class;
fField = field;
}
/**
* Sets a constraint on the field class.
*
* When this instance of ConstrainedFieldPosition is passed to {@link FormattedValue#nextPosition}, positions are
* skipped unless the field is an instance of the class constraint, including subclasses.
*
* Any previously set constraints are cleared.
*
* For example, to loop over only the number-related fields:
*
* <pre>
* ConstrainedFieldPosition cfpos;
* cfpos.constrainClass(NumberFormat.Field.class);
* while (fmtval.nextPosition(cfpos)) {
* // handle the number-related field position
* }
* </pre>
*
* @param classConstraint
* The field class to fix when iterating.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public void constrainClass(Class<?> classConstraint) {
if (classConstraint == null) {
throw new IllegalArgumentException("Cannot constrain on null field class");
}
fConstraint = ConstraintType.CLASS;
fClassConstraint = classConstraint;
fField = null;
}
/**
* Gets the currently active constraint.
*
* @return The currently active constraint type.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public ConstraintType getConstraintType() {
return fConstraint;
}
/**
* Gets the class on which field positions are currently constrained.
*
* @return The class constraint from {@link #constrainClass}, or Object.class by default.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public Class<?> getClassConstraint() {
return fClassConstraint;
}
/**
* Gets the field for the current position.
*
* If a field constraint was set, this function returns the constrained
* field. Otherwise, the return value is well-defined and non-null only after
* FormattedValue#nextPosition returns TRUE.
*
* @return The field saved in the instance. See above for null conditions.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public Field getField() {
return fField;
}
/**
* Gets the INCLUSIVE start index for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The start index saved in the instance.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public int getStart() {
return fStart;
}
/**
* Gets the EXCLUSIVE end index stored for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The end index saved in the instance.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public int getLimit() {
return fLimit;
}
/**
* Gets the value associated with the current field position. The field value is often not set.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The value for the current position. Might be null.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public Object getFieldValue() {
return fValue;
}
/**
* Gets an int64 that FormattedValue implementations may use for storage.
*
* The initial value is zero.
*
* Users of FormattedValue should not need to call this method.
*
* @return The current iteration context from {@link #setInt64IterationContext}.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public long getInt64IterationContext() {
return fContext;
}
/**
* Sets an int64 that FormattedValue implementations may use for storage.
*
* Intended to be used by FormattedValue implementations.
*
* @param context
* The new iteration context.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public void setInt64IterationContext(long context) {
fContext = context;
}
/**
* Sets new values for the primary public getters.
*
* Intended to be used by FormattedValue implementations.
*
* It is up to the implementation to ensure that the user-requested
* constraints are satisfied. This method does not check!
*
* @param field
* The new field.
* @param value
* The new field value.
* @param start
* The new inclusive start index.
* @param limit
* The new exclusive end index.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public void setState(Field field, Object value, int start, int limit) {
fField = field;
fValue = value;
fStart = start;
fLimit = limit;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("CFPos[");
sb.append(fStart);
sb.append('-');
sb.append(fLimit);
sb.append(' ');
sb.append(fField);
sb.append(']');
return sb.toString();
}
}

76
icu4j/main/classes/core/src/com/ibm/icu/text/FormattedValue.java Normal file
View file

@ -0,0 +1,76 @@
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
package com.ibm.icu.text;
import java.text.AttributedCharacterIterator;
import com.ibm.icu.util.ICUUncheckedIOException;
/**
* An abstract formatted value: a string with associated field attributes.
* Many formatters format to classes implementing FormattedValue.
*
* @author sffc
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public interface FormattedValue extends CharSequence {
/**
* Returns the formatted string as a Java String.
*
* Consider using {@link #appendTo} for greater efficiency.
*
* @return The formatted string.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
@Override
public String toString();
/**
* Appends the formatted string to an Appendable.
* <p>
* If an IOException occurs when appending to the Appendable, an unchecked
* {@link ICUUncheckedIOException} is thrown instead.
*
* @param appendable The Appendable to which to append the string output.
* @return The same Appendable, for chaining.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public <A extends Appendable> A appendTo(A appendable);
/**
* Iterates over field positions in the FormattedValue. This lets you determine the position
* of specific types of substrings, like a month or a decimal separator.
*
* To loop over all field positions:
*
* <pre>
* ConstrainableFieldPosition cfpos = new ConstrainableFieldPosition();
* while (fmtval.nextPosition(cfpos)) {
* // handle the field position; get information from cfpos
* }
* </pre>
*
* @param cfpos
* The object used for iteration state. This can provide constraints to iterate over
* only one specific field; see {@link ConstrainedFieldPosition#constrainField}.
* @return true if a new occurrence of the field was found;
* false otherwise.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public boolean nextPosition(ConstrainedFieldPosition cfpos);
/**
* Exports the formatted number as an AttributedCharacterIterator.
* <p>
* Consider using {@link #nextPosition} if you are trying to get field information.
*
* @return An AttributedCharacterIterator containing full field information.
* @draft ICU 64
* @provisional This API might change or be removed in a future release.
*/
public AttributedCharacterIterator toCharacterIterator();
}

243
icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/FormattedValueTest.java Normal file
View file

@ -0,0 +1,243 @@
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
package com.ibm.icu.dev.test.format;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.math.BigDecimal;
import java.text.AttributedCharacterIterator;
import java.text.Format;
import java.text.Format.Field;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
import com.ibm.icu.text.ConstrainedFieldPosition;
import com.ibm.icu.text.ConstrainedFieldPosition.ConstraintType;
import com.ibm.icu.text.FormattedValue;
import com.ibm.icu.text.NumberFormat;
/**
* @author sffc
*/
public class FormattedValueTest {
@Test
public void testBasic() {
ConstrainedFieldPosition cfpos = new ConstrainedFieldPosition();
assertAllPartsEqual(
"basic",
cfpos,
ConstraintType.NONE,
Object.class,
null,
null,
0,
0,
0L);
}
@Test
public void testSetters() {
ConstrainedFieldPosition cfpos = new ConstrainedFieldPosition();
cfpos.constrainField(NumberFormat.Field.COMPACT);
assertAllPartsEqual(
"setters 1",
cfpos,
ConstraintType.FIELD,
Object.class,
NumberFormat.Field.COMPACT,
null,
0,
0,
0L);
cfpos.constrainClass(NumberFormat.Field.class);
assertAllPartsEqual(
"setters 1.5",
cfpos,
ConstraintType.CLASS,
NumberFormat.Field.class,
null,
null,
0,
0,
0L);
cfpos.setInt64IterationContext(42424242424242L);
assertAllPartsEqual(
"setters 2",
cfpos,
ConstraintType.CLASS,
NumberFormat.Field.class,
null,
null,
0,
0,
42424242424242L);
cfpos.setState(NumberFormat.Field.COMPACT, BigDecimal.ONE, 5, 10);
assertAllPartsEqual(
"setters 3",
cfpos,
ConstraintType.CLASS,
NumberFormat.Field.class,
NumberFormat.Field.COMPACT,
BigDecimal.ONE,
5,
10,
42424242424242L);
cfpos.reset();
assertAllPartsEqual(
"setters 4",
cfpos,
ConstraintType.NONE,
Object.class,
null,
null,
0,
0,
0L);
}
private void assertAllPartsEqual(String messagePrefix, ConstrainedFieldPosition cfpos, ConstraintType constraint,
Class<?> classConstraint, Field field, Object value, int start, int limit, long context) {
assertEquals(messagePrefix + ": constraint", constraint, cfpos.getConstraintType());
assertEquals(messagePrefix + ": class constraint", classConstraint, cfpos.getClassConstraint());
assertEquals(messagePrefix + ": field", field, cfpos.getField());
assertEquals(messagePrefix + ": field value", value, cfpos.getFieldValue());
assertEquals(messagePrefix + ": start", start, cfpos.getStart());
assertEquals(messagePrefix + ": limit", limit, cfpos.getLimit());
assertEquals(messagePrefix + ": context", context, cfpos.getInt64IterationContext());
}
public static void checkFormattedValue(String message, FormattedValue fv, String expectedString,
Object[][] expectedFieldPositions) {
// Calculate some initial expected values
int stringLength = fv.toString().length();
HashSet<Format.Field> uniqueFields = new HashSet<>();
Set<Class<?>> uniqueFieldClasses = new HashSet<>();
for (int i=0; i<expectedFieldPositions.length; i++) {
uniqueFields.add((Format.Field) expectedFieldPositions[i][0]);
uniqueFieldClasses.add(expectedFieldPositions[i][0].getClass());
}
String baseMessage = message + ": " + fv.toString() + ": ";
// Check the String and CharSequence
assertEquals(baseMessage + "string", expectedString, fv.toString());
assertCharSequenceEquals(expectedString, fv);
// Check the AttributedCharacterIterator
AttributedCharacterIterator fpi = fv.toCharacterIterator();
Set<AttributedCharacterIterator.Attribute> allAttributes = fpi.getAllAttributeKeys();
assertEquals(baseMessage + "All known fields should be in the iterator", uniqueFields.size(), allAttributes.size());
assertEquals(baseMessage + "Iterator should have length of string output", stringLength, fpi.getEndIndex());
int i = 0;
for (char c = fpi.first(); c != AttributedCharacterIterator.DONE; c = fpi.next(), i++) {
Set<AttributedCharacterIterator.Attribute> currentAttributes = fpi.getAttributes().keySet();
int attributesRemaining = currentAttributes.size();
for (Object[] cas : expectedFieldPositions) {
Format.Field expectedField = (Format.Field) cas[0];
int expectedBeginIndex = (Integer) cas[1];
int expectedEndIndex = (Integer) cas[2];
if (expectedBeginIndex > i || expectedEndIndex <= i) {
// Field position does not overlap with the current character
continue;
}
assertTrue(baseMessage + "Character at " + i + " should have field " + expectedField,
currentAttributes.contains(expectedField));
assertTrue(baseMessage + "Field " + expectedField + " should be a known attribute",
allAttributes.contains(expectedField));
int actualBeginIndex = fpi.getRunStart(expectedField);
int actualEndIndex = fpi.getRunLimit(expectedField);
assertEquals(baseMessage + expectedField + " begin @" + i, expectedBeginIndex, actualBeginIndex);
assertEquals(baseMessage + expectedField + " end @" + i, expectedEndIndex, actualEndIndex);
attributesRemaining--;
}
assertEquals(baseMessage + "Should have looked at every field", 0, attributesRemaining);
}
assertEquals(baseMessage + "Should have looked at every character", stringLength, i);
// Check nextPosition over all fields
ConstrainedFieldPosition cfpos = new ConstrainedFieldPosition();
i = 0;
for (Object[] cas : expectedFieldPositions) {
assertTrue(baseMessage + i, fv.nextPosition(cfpos));
Format.Field expectedField = (Format.Field) cas[0];
int expectedStart = (Integer) cas[1];
int expectedLimit = (Integer) cas[2];
assertEquals(baseMessage + "field " + i, expectedField, cfpos.getField());
assertEquals(baseMessage + "start " + i, expectedStart, cfpos.getStart());
assertEquals(baseMessage + "limit " + i, expectedLimit, cfpos.getLimit());
i++;
}
assertFalse(baseMessage + "after loop", fv.nextPosition(cfpos));
// Check nextPosition constrained over each class one at a time
for (Class<?> classConstraint : uniqueFieldClasses) {
cfpos.reset();
cfpos.constrainClass(classConstraint);
i = 0;
for (Object[] cas : expectedFieldPositions) {
if (cas[0].getClass() != classConstraint) {
continue;
}
assertTrue(baseMessage + i, fv.nextPosition(cfpos));
Format.Field expectedField = (Format.Field) cas[0];
int expectedStart = (Integer) cas[1];
int expectedLimit = (Integer) cas[2];
assertEquals(baseMessage + "field " + i, expectedField, cfpos.getField());
assertEquals(baseMessage + "start " + i, expectedStart, cfpos.getStart());
assertEquals(baseMessage + "limit " + i, expectedLimit, cfpos.getLimit());
i++;
}
assertFalse(baseMessage + "after loop", fv.nextPosition(cfpos));
}
// Check nextPosition constrained over an unrelated class
cfpos.reset();
cfpos.constrainClass(HashSet.class);
assertFalse(baseMessage + "unrelated class", fv.nextPosition(cfpos));
// Check nextPosition constrained over each field one at a time
for (Format.Field field : uniqueFields) {
cfpos.reset();
cfpos.constrainField(field);
i = 0;
for (Object[] cas : expectedFieldPositions) {
if (cas[0] != field) {
continue;
}
assertTrue(baseMessage + i, fv.nextPosition(cfpos));
Format.Field expectedField = (Format.Field) cas[0];
int expectedStart = (Integer) cas[1];
int expectedLimit = (Integer) cas[2];
assertEquals(baseMessage + "field " + i, expectedField, cfpos.getField());
assertEquals(baseMessage + "start " + i, expectedStart, cfpos.getStart());
assertEquals(baseMessage + "limit " + i, expectedLimit, cfpos.getLimit());
i++;
}
assertFalse(baseMessage + "after loop", fv.nextPosition(cfpos));
}
}
public static void assertCharSequenceEquals(CharSequence a, CharSequence b) {
assertEquals(a.toString(), b.toString());
assertEquals(a.length(), b.length());
for (int i = 0; i < a.length(); i++) {
assertEquals(a.charAt(i), b.charAt(i));
}
int start = Math.min(2, a.length());
int end = Math.min(8, a.length());
if (start != end) {
assertCharSequenceEquals(a.subSequence(start, end), b.subSequence(start, end));
}
}
}

68
icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/NumberFormatterApiTest.java
View file

@ -12,7 +12,6 @@ import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.AttributedCharacterIterator;
import java.text.FieldPosition;
import java.text.Format;
import java.util.HashMap;
@ -24,6 +23,7 @@ import java.util.Set;
import org.junit.Ignore;
import org.junit.Test;
import com.ibm.icu.dev.test.format.FormattedValueTest;
import com.ibm.icu.dev.test.serializable.SerializableTestUtility;
import com.ibm.icu.impl.number.Grouper;
import com.ibm.icu.impl.number.LocalizedNumberFormatterAsFormat;
@ -2164,7 +2164,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.DECIMAL_SEPARATOR, 14, 15},
{NumberFormat.Field.FRACTION, 15, 17}};
assertFieldPositions(message, fmtd, expectedFieldPositions);
assertNumberFieldPositions(message, fmtd, expectedFieldPositions);
// Test the iteration functionality of nextFieldPosition
FieldPosition actual = new FieldPosition(NumberFormat.Field.GROUPING_SEPARATOR);
@ -2211,7 +2211,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.MEASURE_UNIT, 2, 4}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2230,7 +2230,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.MEASURE_UNIT, 2, 6}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2250,7 +2250,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.INTEGER, 0, 2},
// note: field starts after the space
{NumberFormat.Field.MEASURE_UNIT, 3, 9}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2270,7 +2270,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.MEASURE_UNIT, 0, 11},
{NumberFormat.Field.INTEGER, 12, 14},
{NumberFormat.Field.MEASURE_UNIT, 15, 19}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2290,7 +2290,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.INTEGER, 0, 2},
// Should trim leading/trailing spaces, but not inner spaces:
{NumberFormat.Field.MEASURE_UNIT, 3, 7}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2312,7 +2312,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 1, 3},
{NumberFormat.Field.MEASURE_UNIT, 4, 5}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2331,7 +2331,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.COMPACT, 2, 3}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2350,7 +2350,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.COMPACT, 3, 11}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2369,7 +2369,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 0, 1},
{NumberFormat.Field.COMPACT, 2, 9}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2388,7 +2388,7 @@ public class NumberFormatterApiTest {
// field, begin index, end index
{NumberFormat.Field.INTEGER, 1, 2},
{NumberFormat.Field.COMPACT, 3, 6}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2408,7 +2408,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.COMPACT, 3, 8},
{NumberFormat.Field.CURRENCY, 9, 12}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2430,7 +2430,7 @@ public class NumberFormatterApiTest {
{NumberFormat.Field.INTEGER, 0, 2},
{NumberFormat.Field.COMPACT, 3, 11},
{NumberFormat.Field.MEASURE_UNIT, 12, 18}};
assertFieldPositions(
assertNumberFieldPositions(
message,
result,
expectedFieldPositions);
@ -2726,43 +2726,7 @@ public class NumberFormatterApiTest {
} catch (UnsupportedOperationException expected) {}
}
static void assertFieldPositions(String message, FormattedNumber formattedNumber, Object[][] expectedFieldPositions) {
// Calculate some initial expected values
int stringLength = formattedNumber.toString().length();
HashSet<Format.Field> uniqueFields = new HashSet<>();
for (int i=0; i<expectedFieldPositions.length; i++) {
uniqueFields.add((Format.Field) expectedFieldPositions[i][0]);
}
String baseMessage = message + ": " + formattedNumber.toString() + ": ";
// Check the AttributedCharacterIterator
AttributedCharacterIterator fpi = formattedNumber.getFieldIterator();
Set<AttributedCharacterIterator.Attribute> allAttributes = fpi.getAllAttributeKeys();
assertEquals(baseMessage + "All known fields should be in the iterator", uniqueFields.size(), allAttributes.size());
assertEquals(baseMessage + "Iterator should have length of string output", stringLength, fpi.getEndIndex());
int i = 0;
for (char c = fpi.first(); c != AttributedCharacterIterator.DONE; c = fpi.next(), i++) {
Set<AttributedCharacterIterator.Attribute> currentAttributes = fpi.getAttributes().keySet();
int attributesRemaining = currentAttributes.size();
for (Object[] cas : expectedFieldPositions) {
NumberFormat.Field expectedField = (NumberFormat.Field) cas[0];
int expectedBeginIndex = (Integer) cas[1];
int expectedEndIndex = (Integer) cas[2];
if (expectedBeginIndex > i || expectedEndIndex <= i) {
// Field position does not overlap with the current character
continue;
}
assertTrue(baseMessage + "Current character should have expected field", currentAttributes.contains(expectedField));
assertTrue(baseMessage + "Field should be a known attribute", allAttributes.contains(expectedField));
int actualBeginIndex = fpi.getRunStart(expectedField);
int actualEndIndex = fpi.getRunLimit(expectedField);
assertEquals(baseMessage + expectedField + " begin @" + i, expectedBeginIndex, actualBeginIndex);
assertEquals(baseMessage + expectedField + " end @" + i, expectedEndIndex, actualEndIndex);
attributesRemaining--;
}
assertEquals(baseMessage + "Should have looked at every field", 0, attributesRemaining);
}
assertEquals(baseMessage + "Should have looked at every character", stringLength, i);
private void assertNumberFieldPositions(String message, FormattedNumber result, Object[][] expectedFieldPositions) {
FormattedValueTest.checkFormattedValue(message, result, result.toString(), expectedFieldPositions);
}
}

53
icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/NumberRangeFormatterTest.java
View file

@ -8,6 +8,8 @@ import java.util.Locale;
import org.junit.Test;
import com.ibm.icu.dev.test.format.FormattedValueTest;
import com.ibm.icu.number.FormattedNumberRange;
import com.ibm.icu.number.LocalizedNumberFormatter;
import com.ibm.icu.number.LocalizedNumberRangeFormatter;
import com.ibm.icu.number.Notation;
@ -19,6 +21,7 @@ import com.ibm.icu.number.NumberRangeFormatter.RangeIdentityFallback;
import com.ibm.icu.number.Precision;
import com.ibm.icu.number.UnlocalizedNumberFormatter;
import com.ibm.icu.number.UnlocalizedNumberRangeFormatter;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.util.Currency;
import com.ibm.icu.util.MeasureUnit;
import com.ibm.icu.util.ULocale;
@ -706,6 +709,50 @@ public class NumberRangeFormatterTest {
}
}
@Test
public void testFieldPositions() {
{
String message = "Field position test 1";
String expectedString = "3K – 5K m";
FormattedNumberRange fmtd = assertFormattedRangeEquals(
message,
NumberRangeFormatter.with()
.numberFormatterBoth(NumberFormatter.with()
.unit(MeasureUnit.METER)
.notation(Notation.compactShort()))
.locale(ULocale.US),
3000,
5000,
expectedString);
Object[][] expectedFieldPositions = new Object[][]{
{NumberFormat.Field.INTEGER, 0, 1},
{NumberFormat.Field.COMPACT, 1, 2},
{NumberFormat.Field.INTEGER, 5, 6},
{NumberFormat.Field.COMPACT, 6, 7},
{NumberFormat.Field.MEASURE_UNIT, 8, 9}};
FormattedValueTest.checkFormattedValue(message, fmtd, expectedString, expectedFieldPositions);
}
{
String message = "Field position test 2";
String expectedString = "87,654,321–98,765,432";
FormattedNumberRange fmtd = assertFormattedRangeEquals(
message,
NumberRangeFormatter.withLocale(ULocale.US),
87654321,
98765432,
expectedString);
Object[][] expectedFieldPositions = new Object[][]{
{NumberFormat.Field.GROUPING_SEPARATOR, 2, 3},
{NumberFormat.Field.GROUPING_SEPARATOR, 6, 7},
{NumberFormat.Field.INTEGER, 0, 10},
{NumberFormat.Field.GROUPING_SEPARATOR, 13, 14},
{NumberFormat.Field.GROUPING_SEPARATOR, 17, 18},
{NumberFormat.Field.INTEGER, 11, 21}};
FormattedValueTest.checkFormattedValue(message, fmtd, expectedString, expectedFieldPositions);
}
}
static void assertFormatRange(
String message,
UnlocalizedNumberRangeFormatter f,
@ -733,10 +780,12 @@ public class NumberRangeFormatterTest {
assertFormattedRangeEquals(message, l, 5e3, 5e6, expected_50K_50M);
}
private static void assertFormattedRangeEquals(String message, LocalizedNumberRangeFormatter l, Number first,
private static FormattedNumberRange assertFormattedRangeEquals(String message, LocalizedNumberRangeFormatter l, Number first,
Number second, String expected) {
String actual = l.formatRange(first, second).toString();
FormattedNumberRange fnr = l.formatRange(first, second);
String actual = fnr.toString();
assertEquals(message + ": " + first + ", " + second, expected, actual);
return fnr;
}
}

4
icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/NumberStringBuilderTest.java
View file

@ -262,6 +262,10 @@ public class NumberStringBuilderTest {
int end = Math.min(12, a.length());
if (start != end) {
assertCharSequenceEquals(a.subSequence(start, end), b.subSequence(start, end));
if (b instanceof NumberStringBuilder) {
NumberStringBuilder bnsb = (NumberStringBuilder) b;
assertCharSequenceEquals(a.subSequence(start, end), bnsb.subString(start, end));
}
}
}
}