[apple/icu.git] / icuSources / i18n / numrange_fluent.cpp

// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

// Allow implicit conversion from char16_t* to UnicodeString for this file:
// Helpful in toString methods and elsewhere.
#define UNISTR_FROM_STRING_EXPLICIT

#include "numrange_impl.h"
#include "util.h"
#include "number_utypes.h"

using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;


// This function needs to be declared in this namespace so it can be friended.
// NOTE: In Java, this logic is handled in the resolve() function.
void icu::number::impl::touchRangeLocales(RangeMacroProps& macros) {
    macros.formatter1.fMacros.locale = macros.locale;
    macros.formatter2.fMacros.locale = macros.locale;
}


template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(const UnlocalizedNumberFormatter& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter1 = formatter;
    copy.fMacros.singleFormatter = true;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(const UnlocalizedNumberFormatter& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter1 = formatter;
    move.fMacros.singleFormatter = true;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(UnlocalizedNumberFormatter&& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter1 = std::move(formatter);
    copy.fMacros.singleFormatter = true;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(UnlocalizedNumberFormatter&& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter1 = std::move(formatter);
    move.fMacros.singleFormatter = true;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(const UnlocalizedNumberFormatter& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter1 = formatter;
    copy.fMacros.singleFormatter = false;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(const UnlocalizedNumberFormatter& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter1 = formatter;
    move.fMacros.singleFormatter = false;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(UnlocalizedNumberFormatter&& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter1 = std::move(formatter);
    copy.fMacros.singleFormatter = false;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(UnlocalizedNumberFormatter&& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter1 = std::move(formatter);
    move.fMacros.singleFormatter = false;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(const UnlocalizedNumberFormatter& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter2 = formatter;
    copy.fMacros.singleFormatter = false;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(const UnlocalizedNumberFormatter& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter2 = formatter;
    move.fMacros.singleFormatter = false;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(UnlocalizedNumberFormatter&& formatter) const& {
    Derived copy(*this);
    copy.fMacros.formatter2 = std::move(formatter);
    copy.fMacros.singleFormatter = false;
    touchRangeLocales(copy.fMacros);
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(UnlocalizedNumberFormatter&& formatter) && {
    Derived move(std::move(*this));
    move.fMacros.formatter2 = std::move(formatter);
    move.fMacros.singleFormatter = false;
    touchRangeLocales(move.fMacros);
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::collapse(UNumberRangeCollapse collapse) const& {
    Derived copy(*this);
    copy.fMacros.collapse = collapse;
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::collapse(UNumberRangeCollapse collapse) && {
    Derived move(std::move(*this));
    move.fMacros.collapse = collapse;
    return move;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::identityFallback(UNumberRangeIdentityFallback identityFallback) const& {
    Derived copy(*this);
    copy.fMacros.identityFallback = identityFallback;
    return copy;
}

template<typename Derived>
Derived NumberRangeFormatterSettings<Derived>::identityFallback(UNumberRangeIdentityFallback identityFallback) && {
    Derived move(std::move(*this));
    move.fMacros.identityFallback = identityFallback;
    return move;
}

template<typename Derived>
LocalPointer<Derived> NumberRangeFormatterSettings<Derived>::clone() const & {
    return LocalPointer<Derived>(new Derived(*this));
}

template<typename Derived>
LocalPointer<Derived> NumberRangeFormatterSettings<Derived>::clone() && {
    return LocalPointer<Derived>(new Derived(std::move(*this)));
}

// Declare all classes that implement NumberRangeFormatterSettings
// See https://stackoverflow.com/a/495056/1407170
template
class icu::number::NumberRangeFormatterSettings<icu::number::UnlocalizedNumberRangeFormatter>;
template
class icu::number::NumberRangeFormatterSettings<icu::number::LocalizedNumberRangeFormatter>;


UnlocalizedNumberRangeFormatter NumberRangeFormatter::with() {
    UnlocalizedNumberRangeFormatter result;
    return result;
}

LocalizedNumberRangeFormatter NumberRangeFormatter::withLocale(const Locale& locale) {
    return with().locale(locale);
}


template<typename T> using NFS = NumberRangeFormatterSettings<T>;
using LNF = LocalizedNumberRangeFormatter;
using UNF = UnlocalizedNumberRangeFormatter;

UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(const UNF& other)
        : UNF(static_cast<const NFS<UNF>&>(other)) {}

UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(const NFS<UNF>& other)
        : NFS<UNF>(other) {
    // No additional fields to assign
}

// Make default copy constructor call the NumberRangeFormatterSettings copy constructor.
UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(UNF&& src) U_NOEXCEPT
        : UNF(static_cast<NFS<UNF>&&>(src)) {}

UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(NFS<UNF>&& src) U_NOEXCEPT
        : NFS<UNF>(std::move(src)) {
    // No additional fields to assign
}

UnlocalizedNumberRangeFormatter& UnlocalizedNumberRangeFormatter::operator=(const UNF& other) {
    NFS<UNF>::operator=(static_cast<const NFS<UNF>&>(other));
    // No additional fields to assign
    return *this;
}

UnlocalizedNumberRangeFormatter& UnlocalizedNumberRangeFormatter::operator=(UNF&& src) U_NOEXCEPT {
    NFS<UNF>::operator=(static_cast<NFS<UNF>&&>(src));
    // No additional fields to assign
    return *this;
}

// Make default copy constructor call the NumberRangeFormatterSettings copy constructor.
LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const LNF& other)
        : LNF(static_cast<const NFS<LNF>&>(other)) {}

LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const NFS<LNF>& other)
        : NFS<LNF>(other) {
    // No additional fields to assign
}

LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(LocalizedNumberRangeFormatter&& src) U_NOEXCEPT
        : LNF(static_cast<NFS<LNF>&&>(src)) {}

LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(NFS<LNF>&& src) U_NOEXCEPT
        : NFS<LNF>(std::move(src)) {
    // Steal the compiled formatter
    LNF&& _src = static_cast<LNF&&>(src);
    auto* stolen = _src.fAtomicFormatter.exchange(nullptr);
    delete fAtomicFormatter.exchange(stolen);
}

LocalizedNumberRangeFormatter& LocalizedNumberRangeFormatter::operator=(const LNF& other) {
    NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
    // Do not steal; just clear
    delete fAtomicFormatter.exchange(nullptr);
    return *this;
}

LocalizedNumberRangeFormatter& LocalizedNumberRangeFormatter::operator=(LNF&& src) U_NOEXCEPT {
    NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
    // Steal the compiled formatter
    auto* stolen = src.fAtomicFormatter.exchange(nullptr);
    delete fAtomicFormatter.exchange(stolen);
    return *this;
}


LocalizedNumberRangeFormatter::~LocalizedNumberRangeFormatter() {
    delete fAtomicFormatter.exchange(nullptr);
}

LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const RangeMacroProps& macros, const Locale& locale) {
    fMacros = macros;
    fMacros.locale = locale;
    touchRangeLocales(fMacros);
}

LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(RangeMacroProps&& macros, const Locale& locale) {
    fMacros = std::move(macros);
    fMacros.locale = locale;
    touchRangeLocales(fMacros);
}

LocalizedNumberRangeFormatter UnlocalizedNumberRangeFormatter::locale(const Locale& locale) const& {
    return LocalizedNumberRangeFormatter(fMacros, locale);
}

LocalizedNumberRangeFormatter UnlocalizedNumberRangeFormatter::locale(const Locale& locale)&& {
    return LocalizedNumberRangeFormatter(std::move(fMacros), locale);
}


FormattedNumberRange LocalizedNumberRangeFormatter::formatFormattableRange(
        const Formattable& first, const Formattable& second, UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return FormattedNumberRange(U_ILLEGAL_ARGUMENT_ERROR);
    }

    auto results = new UFormattedNumberRangeData();
    if (results == nullptr) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return FormattedNumberRange(status);
    }

    first.populateDecimalQuantity(results->quantity1, status);
    if (U_FAILURE(status)) {
        return FormattedNumberRange(status);
    }

    second.populateDecimalQuantity(results->quantity2, status);
    if (U_FAILURE(status)) {
        return FormattedNumberRange(status);
    }

    formatImpl(*results, first == second, status);

    // Do not save the results object if we encountered a failure.
    if (U_SUCCESS(status)) {
        return FormattedNumberRange(results);
    } else {
        delete results;
        return FormattedNumberRange(status);
    }
}

void LocalizedNumberRangeFormatter::formatImpl(
        UFormattedNumberRangeData& results, bool equalBeforeRounding, UErrorCode& status) const {
    auto* impl = getFormatter(status);
    if (U_FAILURE(status)) {
        return;
    }
    if (impl == nullptr) {
        status = U_INTERNAL_PROGRAM_ERROR;
        return;
    }
    impl->format(results, equalBeforeRounding, status);
    if (U_FAILURE(status)) {
        return;
    }
    results.getStringRef().writeTerminator(status);
}

const impl::NumberRangeFormatterImpl*
LocalizedNumberRangeFormatter::getFormatter(UErrorCode& status) const {
    // TODO: Move this into umutex.h? (similar logic also in decimfmt.cpp)
    // See ICU-20146

    if (U_FAILURE(status)) {
        return nullptr;
    }

    // First try to get the pre-computed formatter
    auto* ptr = fAtomicFormatter.load();
    if (ptr != nullptr) {
        return ptr;
    }

    // Try computing the formatter on our own
    auto* temp = new NumberRangeFormatterImpl(fMacros, status);
    if (U_FAILURE(status)) {
        return nullptr;
    }
    if (temp == nullptr) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return nullptr;
    }

    // Note: ptr starts as nullptr; during compare_exchange,
    // it is set to what is actually stored in the atomic
    // if another thread beat us to computing the formatter object.
    auto* nonConstThis = const_cast<LocalizedNumberRangeFormatter*>(this);
    if (!nonConstThis->fAtomicFormatter.compare_exchange_strong(ptr, temp)) {
        // Another thread beat us to computing the formatter
        delete temp;
        return ptr;
    } else {
        // Our copy of the formatter got stored in the atomic
        return temp;
    }

}


UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedNumberRange)

#define UPRV_NOARG

UBool FormattedNumberRange::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
    UPRV_FORMATTED_VALUE_METHOD_GUARD(FALSE)
    // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
    return fData->getStringRef().nextFieldPosition(fieldPosition, status) ? TRUE : FALSE;
}

void FormattedNumberRange::getAllFieldPositions(FieldPositionIterator& iterator, UErrorCode& status) const {
    FieldPositionIteratorHandler fpih(&iterator, status);
    getAllFieldPositionsImpl(fpih, status);
}

void FormattedNumberRange::getAllFieldPositionsImpl(
        FieldPositionIteratorHandler& fpih, UErrorCode& status) const {
    UPRV_FORMATTED_VALUE_METHOD_GUARD(UPRV_NOARG)
    fData->getStringRef().getAllFieldPositions(fpih, status);
}

UnicodeString FormattedNumberRange::getFirstDecimal(UErrorCode& status) const {
    UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
    return fData->quantity1.toScientificString();
}

UnicodeString FormattedNumberRange::getSecondDecimal(UErrorCode& status) const {
    UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
    return fData->quantity2.toScientificString();
}

UNumberRangeIdentityResult FormattedNumberRange::getIdentityResult(UErrorCode& status) const {
    UPRV_FORMATTED_VALUE_METHOD_GUARD(UNUM_IDENTITY_RESULT_NOT_EQUAL)
    return fData->identityResult;
}


UFormattedNumberRangeData::~UFormattedNumberRangeData() = default;


#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
3d1f044b A	1	// © 2018 and later: Unicode, Inc. and others.
	2	// License & terms of use: http://www.unicode.org/copyright.html
	3
	4	#include "unicode/utypes.h"
	5
	6	#if !UCONFIG_NO_FORMATTING
	7
	8	// Allow implicit conversion from char16_t* to UnicodeString for this file:
	9	// Helpful in toString methods and elsewhere.
	10	#define UNISTR_FROM_STRING_EXPLICIT
	11
	12	#include "numrange_impl.h"
	13	#include "util.h"
	14	#include "number_utypes.h"
	15
	16	using namespace icu;
	17	using namespace icu::number;
	18	using namespace icu::number::impl;
	19
	20
	21	// This function needs to be declared in this namespace so it can be friended.
	22	// NOTE: In Java, this logic is handled in the resolve() function.
	23	void icu::number::impl::touchRangeLocales(RangeMacroProps& macros) {
	24	macros.formatter1.fMacros.locale = macros.locale;
	25	macros.formatter2.fMacros.locale = macros.locale;
	26	}
	27
	28
	29	template<typename Derived>
	30	Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(const UnlocalizedNumberFormatter& formatter) const& {
	31	Derived copy(*this);
	32	copy.fMacros.formatter1 = formatter;
	33	copy.fMacros.singleFormatter = true;
	34	touchRangeLocales(copy.fMacros);
	35	return copy;
	36	}
	37
	38	template<typename Derived>
	39	Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(const UnlocalizedNumberFormatter& formatter) && {
	40	Derived move(std::move(*this));
	41	move.fMacros.formatter1 = formatter;
	42	move.fMacros.singleFormatter = true;
	43	touchRangeLocales(move.fMacros);
	44	return move;
	45	}
	46
	47	template<typename Derived>
	48	Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(UnlocalizedNumberFormatter&& formatter) const& {
	49	Derived copy(*this);
	50	copy.fMacros.formatter1 = std::move(formatter);
	51	copy.fMacros.singleFormatter = true;
	52	touchRangeLocales(copy.fMacros);
	53	return copy;
	54	}
	55
	56	template<typename Derived>
	57	Derived NumberRangeFormatterSettings<Derived>::numberFormatterBoth(UnlocalizedNumberFormatter&& formatter) && {
	58	Derived move(std::move(*this));
	59	move.fMacros.formatter1 = std::move(formatter);
	60	move.fMacros.singleFormatter = true;
	61	touchRangeLocales(move.fMacros);
	62	return move;
	63	}
	64
65	template<typename Derived>
66	Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(const UnlocalizedNumberFormatter& formatter) const& {
67	Derived copy(*this);
68	copy.fMacros.formatter1 = formatter;
69	copy.fMacros.singleFormatter = false;
70	touchRangeLocales(copy.fMacros);
71	return copy;
72	}
73
74	template<typename Derived>
75	Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(const UnlocalizedNumberFormatter& formatter) && {
76	Derived move(std::move(*this));
77	move.fMacros.formatter1 = formatter;
78	move.fMacros.singleFormatter = false;
79	touchRangeLocales(move.fMacros);
80	return move;
81	}
82
83	template<typename Derived>
84	Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(UnlocalizedNumberFormatter&& formatter) const& {
85	Derived copy(*this);
86	copy.fMacros.formatter1 = std::move(formatter);
87	copy.fMacros.singleFormatter = false;
88	touchRangeLocales(copy.fMacros);
89	return copy;
90	}
91
92	template<typename Derived>
93	Derived NumberRangeFormatterSettings<Derived>::numberFormatterFirst(UnlocalizedNumberFormatter&& formatter) && {
94	Derived move(std::move(*this));
95	move.fMacros.formatter1 = std::move(formatter);
96	move.fMacros.singleFormatter = false;
97	touchRangeLocales(move.fMacros);
98	return move;
99	}
100
101	template<typename Derived>
102	Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(const UnlocalizedNumberFormatter& formatter) const& {
103	Derived copy(*this);
104	copy.fMacros.formatter2 = formatter;
105	copy.fMacros.singleFormatter = false;
106	touchRangeLocales(copy.fMacros);
107	return copy;
108	}
109
110	template<typename Derived>
111	Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(const UnlocalizedNumberFormatter& formatter) && {
112	Derived move(std::move(*this));
113	move.fMacros.formatter2 = formatter;
114	move.fMacros.singleFormatter = false;
115	touchRangeLocales(move.fMacros);
116	return move;
117	}
118
119	template<typename Derived>
120	Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(UnlocalizedNumberFormatter&& formatter) const& {
121	Derived copy(*this);
122	copy.fMacros.formatter2 = std::move(formatter);
123	copy.fMacros.singleFormatter = false;
124	touchRangeLocales(copy.fMacros);
125	return copy;
126	}
127
128	template<typename Derived>
129	Derived NumberRangeFormatterSettings<Derived>::numberFormatterSecond(UnlocalizedNumberFormatter&& formatter) && {
130	Derived move(std::move(*this));
131	move.fMacros.formatter2 = std::move(formatter);
132	move.fMacros.singleFormatter = false;
133	touchRangeLocales(move.fMacros);
134	return move;
135	}
136
137	template<typename Derived>
138	Derived NumberRangeFormatterSettings<Derived>::collapse(UNumberRangeCollapse collapse) const& {
139	Derived copy(*this);
140	copy.fMacros.collapse = collapse;
141	return copy;
142	}
143
144	template<typename Derived>
145	Derived NumberRangeFormatterSettings<Derived>::collapse(UNumberRangeCollapse collapse) && {
146	Derived move(std::move(*this));
147	move.fMacros.collapse = collapse;
148	return move;
149	}
150
151	template<typename Derived>
152	Derived NumberRangeFormatterSettings<Derived>::identityFallback(UNumberRangeIdentityFallback identityFallback) const& {
153	Derived copy(*this);
154	copy.fMacros.identityFallback = identityFallback;
155	return copy;
156	}
157
158	template<typename Derived>
159	Derived NumberRangeFormatterSettings<Derived>::identityFallback(UNumberRangeIdentityFallback identityFallback) && {
160	Derived move(std::move(*this));
161	move.fMacros.identityFallback = identityFallback;
162	return move;
163	}
164
165	template<typename Derived>
166	LocalPointer<Derived> NumberRangeFormatterSettings<Derived>::clone() const & {
167	return LocalPointer<Derived>(new Derived(*this));
168	}
169
170	template<typename Derived>
171	LocalPointer<Derived> NumberRangeFormatterSettings<Derived>::clone() && {
172	return LocalPointer<Derived>(new Derived(std::move(*this)));
173	}
174
175	// Declare all classes that implement NumberRangeFormatterSettings
176	// See https://stackoverflow.com/a/495056/1407170
177	template
178	class icu::number::NumberRangeFormatterSettings<icu::number::UnlocalizedNumberRangeFormatter>;
179	template
180	class icu::number::NumberRangeFormatterSettings<icu::number::LocalizedNumberRangeFormatter>;
181
182
183	UnlocalizedNumberRangeFormatter NumberRangeFormatter::with() {
184	UnlocalizedNumberRangeFormatter result;
185	return result;
186	}
187
188	LocalizedNumberRangeFormatter NumberRangeFormatter::withLocale(const Locale& locale) {
189	return with().locale(locale);
190	}
191
192
193	template<typename T> using NFS = NumberRangeFormatterSettings<T>;
194	using LNF = LocalizedNumberRangeFormatter;
195	using UNF = UnlocalizedNumberRangeFormatter;
196
197	UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(const UNF& other)
198	: UNF(static_cast<const NFS<UNF>&>(other)) {}
199
200	UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(const NFS<UNF>& other)
201	: NFS<UNF>(other) {
202	// No additional fields to assign
203	}
204
205	// Make default copy constructor call the NumberRangeFormatterSettings copy constructor.
206	UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(UNF&& src) U_NOEXCEPT
207	: UNF(static_cast<NFS<UNF>&&>(src)) {}
208
209	UnlocalizedNumberRangeFormatter::UnlocalizedNumberRangeFormatter(NFS<UNF>&& src) U_NOEXCEPT
210	: NFS<UNF>(std::move(src)) {
211	// No additional fields to assign
212	}
213
214	UnlocalizedNumberRangeFormatter& UnlocalizedNumberRangeFormatter::operator=(const UNF& other) {
215	NFS<UNF>::operator=(static_cast<const NFS<UNF>&>(other));
216	// No additional fields to assign
217	return *this;
218	}
219
220	UnlocalizedNumberRangeFormatter& UnlocalizedNumberRangeFormatter::operator=(UNF&& src) U_NOEXCEPT {
221	NFS<UNF>::operator=(static_cast<NFS<UNF>&&>(src));
222	// No additional fields to assign
223	return *this;
224	}
225
226	// Make default copy constructor call the NumberRangeFormatterSettings copy constructor.
227	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const LNF& other)
228	: LNF(static_cast<const NFS<LNF>&>(other)) {}
229
230	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const NFS<LNF>& other)
231	: NFS<LNF>(other) {
232	// No additional fields to assign
233	}
234
235	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(LocalizedNumberRangeFormatter&& src) U_NOEXCEPT
236	: LNF(static_cast<NFS<LNF>&&>(src)) {}
237
238	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(NFS<LNF>&& src) U_NOEXCEPT
239	: NFS<LNF>(std::move(src)) {
240	// Steal the compiled formatter
241	LNF&& _src = static_cast<LNF&&>(src);
242	auto* stolen = _src.fAtomicFormatter.exchange(nullptr);
243	delete fAtomicFormatter.exchange(stolen);
244	}
245
246	LocalizedNumberRangeFormatter& LocalizedNumberRangeFormatter::operator=(const LNF& other) {
247	NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
248	// Do not steal; just clear
249	delete fAtomicFormatter.exchange(nullptr);
250	return *this;
251	}
252
253	LocalizedNumberRangeFormatter& LocalizedNumberRangeFormatter::operator=(LNF&& src) U_NOEXCEPT {
254	NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
255	// Steal the compiled formatter
256	auto* stolen = src.fAtomicFormatter.exchange(nullptr);
257	delete fAtomicFormatter.exchange(stolen);
258	return *this;
259	}
260
261
262	LocalizedNumberRangeFormatter::~LocalizedNumberRangeFormatter() {
263	delete fAtomicFormatter.exchange(nullptr);
264	}
265
266	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(const RangeMacroProps& macros, const Locale& locale) {
267	fMacros = macros;
268	fMacros.locale = locale;
269	touchRangeLocales(fMacros);
270	}
271
272	LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(RangeMacroProps&& macros, const Locale& locale) {
273	fMacros = std::move(macros);
274	fMacros.locale = locale;
275	touchRangeLocales(fMacros);
276	}
277
278	LocalizedNumberRangeFormatter UnlocalizedNumberRangeFormatter::locale(const Locale& locale) const& {
279	return LocalizedNumberRangeFormatter(fMacros, locale);
280	}
281
282	LocalizedNumberRangeFormatter UnlocalizedNumberRangeFormatter::locale(const Locale& locale)&& {
283	return LocalizedNumberRangeFormatter(std::move(fMacros), locale);
284	}
285
286
287	FormattedNumberRange LocalizedNumberRangeFormatter::formatFormattableRange(
288	const Formattable& first, const Formattable& second, UErrorCode& status) const {
289	if (U_FAILURE(status)) {
290	return FormattedNumberRange(U_ILLEGAL_ARGUMENT_ERROR);
291	}
292
293	auto results = new UFormattedNumberRangeData();
294	if (results == nullptr) {
295	status = U_MEMORY_ALLOCATION_ERROR;
296	return FormattedNumberRange(status);
297	}
298
299	first.populateDecimalQuantity(results->quantity1, status);
300	if (U_FAILURE(status)) {
301	return FormattedNumberRange(status);
302	}
303
304	second.populateDecimalQuantity(results->quantity2, status);
305	if (U_FAILURE(status)) {
306	return FormattedNumberRange(status);
307	}
308
309	formatImpl(*results, first == second, status);
310
311	// Do not save the results object if we encountered a failure.
312	if (U_SUCCESS(status)) {
313	return FormattedNumberRange(results);
314	} else {
315	delete results;
316	return FormattedNumberRange(status);
317	}
318	}
319
320	void LocalizedNumberRangeFormatter::formatImpl(
321	UFormattedNumberRangeData& results, bool equalBeforeRounding, UErrorCode& status) const {
322	auto* impl = getFormatter(status);
323	if (U_FAILURE(status)) {
324	return;
325	}
326	if (impl == nullptr) {
327	status = U_INTERNAL_PROGRAM_ERROR;
328	return;
329	}
330	impl->format(results, equalBeforeRounding, status);
331	if (U_FAILURE(status)) {
332	return;
333	}
334	results.getStringRef().writeTerminator(status);
335	}
336
337	const impl::NumberRangeFormatterImpl*
338	LocalizedNumberRangeFormatter::getFormatter(UErrorCode& status) const {
339	// TODO: Move this into umutex.h? (similar logic also in decimfmt.cpp)
340	// See ICU-20146
341
342	if (U_FAILURE(status)) {
343	return nullptr;
344	}
345
346	// First try to get the pre-computed formatter
347	auto* ptr = fAtomicFormatter.load();
348	if (ptr != nullptr) {
349	return ptr;
350	}
351
352	// Try computing the formatter on our own
353	auto* temp = new NumberRangeFormatterImpl(fMacros, status);
354	if (U_FAILURE(status)) {
355	return nullptr;
356	}
357	if (temp == nullptr) {
358	status = U_MEMORY_ALLOCATION_ERROR;
359	return nullptr;
360	}
361
362	// Note: ptr starts as nullptr; during compare_exchange,
363	// it is set to what is actually stored in the atomic
364	// if another thread beat us to computing the formatter object.
365	auto* nonConstThis = const_cast<LocalizedNumberRangeFormatter*>(this);
366	if (!nonConstThis->fAtomicFormatter.compare_exchange_strong(ptr, temp)) {
367	// Another thread beat us to computing the formatter
368	delete temp;
369	return ptr;
370	} else {
371	// Our copy of the formatter got stored in the atomic
372	return temp;
373	}
374
375	}
376
377
378	UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedNumberRange)
379
380	#define UPRV_NOARG
381
382	UBool FormattedNumberRange::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
383	UPRV_FORMATTED_VALUE_METHOD_GUARD(FALSE)
384	// NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
385	return fData->getStringRef().nextFieldPosition(fieldPosition, status) ? TRUE : FALSE;
386	}
387
388	void FormattedNumberRange::getAllFieldPositions(FieldPositionIterator& iterator, UErrorCode& status) const {
389	FieldPositionIteratorHandler fpih(&iterator, status);
390	getAllFieldPositionsImpl(fpih, status);
391	}
392
393	void FormattedNumberRange::getAllFieldPositionsImpl(
394	FieldPositionIteratorHandler& fpih, UErrorCode& status) const {
395	UPRV_FORMATTED_VALUE_METHOD_GUARD(UPRV_NOARG)
396	fData->getStringRef().getAllFieldPositions(fpih, status);
397	}
398
399	UnicodeString FormattedNumberRange::getFirstDecimal(UErrorCode& status) const {
400	UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
401	return fData->quantity1.toScientificString();
402	}
403
404	UnicodeString FormattedNumberRange::getSecondDecimal(UErrorCode& status) const {
405	UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
406	return fData->quantity2.toScientificString();
407	}
408
409	UNumberRangeIdentityResult FormattedNumberRange::getIdentityResult(UErrorCode& status) const {
410	UPRV_FORMATTED_VALUE_METHOD_GUARD(UNUM_IDENTITY_RESULT_NOT_EQUAL)
411	return fData->identityResult;
412	}
413
414
415	UFormattedNumberRangeData::~UFormattedNumberRangeData() = default;
416
417
418
419	#endif /* #if !UCONFIG_NO_FORMATTING */