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

// © 2017 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 "number_stringbuilder.h"
#include "unicode/utf16.h"

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

namespace {

// A version of uprv_memcpy that checks for length 0.
// By default, uprv_memcpy requires a length of at least 1.
inline void uprv_memcpy2(void* dest, const void* src, size_t len) {
    if (len > 0) {
        uprv_memcpy(dest, src, len);
    }
}

// A version of uprv_memmove that checks for length 0.
// By default, uprv_memmove requires a length of at least 1.
inline void uprv_memmove2(void* dest, const void* src, size_t len) {
    if (len > 0) {
        uprv_memmove(dest, src, len);
    }
}

} // namespace

NumberStringBuilder::NumberStringBuilder() = default;

NumberStringBuilder::~NumberStringBuilder() {
    if (fUsingHeap) {
        uprv_free(fChars.heap.ptr);
        uprv_free(fFields.heap.ptr);
    }
}

NumberStringBuilder::NumberStringBuilder(const NumberStringBuilder &other) {
    *this = other;
}

NumberStringBuilder &NumberStringBuilder::operator=(const NumberStringBuilder &other) {
    // Check for self-assignment
    if (this == &other) {
        return *this;
    }

    // Continue with deallocation and copying
    if (fUsingHeap) {
        uprv_free(fChars.heap.ptr);
        uprv_free(fFields.heap.ptr);
        fUsingHeap = false;
    }

    int32_t capacity = other.getCapacity();
    if (capacity > DEFAULT_CAPACITY) {
        // FIXME: uprv_malloc
        // C++ note: malloc appears in two places: here and in prepareForInsertHelper.
        auto newChars = static_cast<char16_t *> (uprv_malloc(sizeof(char16_t) * capacity));
        auto newFields = static_cast<Field *>(uprv_malloc(sizeof(Field) * capacity));
        if (newChars == nullptr || newFields == nullptr) {
            // UErrorCode is not available; fail silently.
            uprv_free(newChars);
            uprv_free(newFields);
            *this = NumberStringBuilder();  // can't fail
            return *this;
        }

        fUsingHeap = true;
        fChars.heap.capacity = capacity;
        fChars.heap.ptr = newChars;
        fFields.heap.capacity = capacity;
        fFields.heap.ptr = newFields;
    }

    uprv_memcpy2(getCharPtr(), other.getCharPtr(), sizeof(char16_t) * capacity);
    uprv_memcpy2(getFieldPtr(), other.getFieldPtr(), sizeof(Field) * capacity);

    fZero = other.fZero;
    fLength = other.fLength;
    return *this;
}

int32_t NumberStringBuilder::length() const {
    return fLength;
}

int32_t NumberStringBuilder::codePointCount() const {
    return u_countChar32(getCharPtr() + fZero, fLength);
}

UChar32 NumberStringBuilder::getFirstCodePoint() const {
    if (fLength == 0) {
        return -1;
    }
    UChar32 cp;
    U16_GET(getCharPtr() + fZero, 0, 0, fLength, cp);
    return cp;
}

UChar32 NumberStringBuilder::getLastCodePoint() const {
    if (fLength == 0) {
        return -1;
    }
    int32_t offset = fLength;
    U16_BACK_1(getCharPtr() + fZero, 0, offset);
    UChar32 cp;
    U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);
    return cp;
}

UChar32 NumberStringBuilder::codePointAt(int32_t index) const {
    UChar32 cp;
    U16_GET(getCharPtr() + fZero, 0, index, fLength, cp);
    return cp;
}

UChar32 NumberStringBuilder::codePointBefore(int32_t index) const {
    int32_t offset = index;
    U16_BACK_1(getCharPtr() + fZero, 0, offset);
    UChar32 cp;
    U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);
    return cp;
}

NumberStringBuilder &NumberStringBuilder::clear() {
    // TODO: Reset the heap here?
    fZero = getCapacity() / 2;
    fLength = 0;
    return *this;
}

int32_t NumberStringBuilder::appendCodePoint(UChar32 codePoint, Field field, UErrorCode &status) {
    return insertCodePoint(fLength, codePoint, field, status);
}

int32_t
NumberStringBuilder::insertCodePoint(int32_t index, UChar32 codePoint, Field field, UErrorCode &status) {
    int32_t count = U16_LENGTH(codePoint);
    int32_t position = prepareForInsert(index, count, status);
    if (U_FAILURE(status)) {
        return count;
    }
    if (count == 1) {
        getCharPtr()[position] = (char16_t) codePoint;
        getFieldPtr()[position] = field;
    } else {
        getCharPtr()[position] = U16_LEAD(codePoint);
        getCharPtr()[position + 1] = U16_TRAIL(codePoint);
        getFieldPtr()[position] = getFieldPtr()[position + 1] = field;
    }
    return count;
}

int32_t NumberStringBuilder::append(const UnicodeString &unistr, Field field, UErrorCode &status) {
    return insert(fLength, unistr, field, status);
}

int32_t NumberStringBuilder::insert(int32_t index, const UnicodeString &unistr, Field field,
                                    UErrorCode &status) {
    if (unistr.length() == 0) {
        // Nothing to insert.
        return 0;
    } else if (unistr.length() == 1) {
        // Fast path: insert using insertCodePoint.
        return insertCodePoint(index, unistr.charAt(0), field, status);
    } else {
        return insert(index, unistr, 0, unistr.length(), field, status);
    }
}

int32_t
NumberStringBuilder::insert(int32_t index, const UnicodeString &unistr, int32_t start, int32_t end,
                            Field field, UErrorCode &status) {
    int32_t count = end - start;
    int32_t position = prepareForInsert(index, count, status);
    if (U_FAILURE(status)) {
        return count;
    }
    for (int32_t i = 0; i < count; i++) {
        getCharPtr()[position + i] = unistr.charAt(start + i);
        getFieldPtr()[position + i] = field;
    }
    return count;
}

int32_t
NumberStringBuilder::splice(int32_t startThis, int32_t endThis,  const UnicodeString &unistr,
                            int32_t startOther, int32_t endOther, Field field, UErrorCode& status) {
    int32_t thisLength = endThis - startThis;
    int32_t otherLength = endOther - startOther;
    int32_t count = otherLength - thisLength;
    int32_t position;
    if (count > 0) {
        // Overall, chars need to be added.
        position = prepareForInsert(startThis, count, status);
    } else {
        // Overall, chars need to be removed or kept the same.
        position = remove(startThis, -count);
    }
    if (U_FAILURE(status)) {
        return count;
    }
    for (int32_t i = 0; i < otherLength; i++) {
        getCharPtr()[position + i] = unistr.charAt(startOther + i);
        getFieldPtr()[position + i] = field;
    }
    return count;
}

int32_t NumberStringBuilder::append(const NumberStringBuilder &other, UErrorCode &status) {
    return insert(fLength, other, status);
}

int32_t
NumberStringBuilder::insert(int32_t index, const NumberStringBuilder &other, UErrorCode &status) {
    if (this == &other) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    int32_t count = other.fLength;
    if (count == 0) {
        // Nothing to insert.
        return 0;
    }
    int32_t position = prepareForInsert(index, count, status);
    if (U_FAILURE(status)) {
        return count;
    }
    for (int32_t i = 0; i < count; i++) {
        getCharPtr()[position + i] = other.charAt(i);
        getFieldPtr()[position + i] = other.fieldAt(i);
    }
    return count;
}

int32_t NumberStringBuilder::prepareForInsert(int32_t index, int32_t count, UErrorCode &status) {
    if (index == 0 && fZero - count >= 0) {
        // Append to start
        fZero -= count;
        fLength += count;
        return fZero;
    } else if (index == fLength && fZero + fLength + count < getCapacity()) {
        // Append to end
        fLength += count;
        return fZero + fLength - count;
    } else {
        // Move chars around and/or allocate more space
        return prepareForInsertHelper(index, count, status);
    }
}

int32_t NumberStringBuilder::prepareForInsertHelper(int32_t index, int32_t count, UErrorCode &status) {
    int32_t oldCapacity = getCapacity();
    int32_t oldZero = fZero;
    char16_t *oldChars = getCharPtr();
    Field *oldFields = getFieldPtr();
    if (fLength + count > oldCapacity) {
        int32_t newCapacity = (fLength + count) * 2;
        int32_t newZero = newCapacity / 2 - (fLength + count) / 2;

        // C++ note: malloc appears in two places: here and in the assignment operator.
        auto newChars = static_cast<char16_t *> (uprv_malloc(sizeof(char16_t) * newCapacity));
        auto newFields = static_cast<Field *>(uprv_malloc(sizeof(Field) * newCapacity));
        if (newChars == nullptr || newFields == nullptr) {
            uprv_free(newChars);
            uprv_free(newFields);
            status = U_MEMORY_ALLOCATION_ERROR;
            return -1;
        }

        // First copy the prefix and then the suffix, leaving room for the new chars that the
        // caller wants to insert.
        // C++ note: memcpy is OK because the src and dest do not overlap.
        uprv_memcpy2(newChars + newZero, oldChars + oldZero, sizeof(char16_t) * index);
        uprv_memcpy2(newChars + newZero + index + count,
                oldChars + oldZero + index,
                sizeof(char16_t) * (fLength - index));
        uprv_memcpy2(newFields + newZero, oldFields + oldZero, sizeof(Field) * index);
        uprv_memcpy2(newFields + newZero + index + count,
                oldFields + oldZero + index,
                sizeof(Field) * (fLength - index));

        if (fUsingHeap) {
            uprv_free(oldChars);
            uprv_free(oldFields);
        }
        fUsingHeap = true;
        fChars.heap.ptr = newChars;
        fChars.heap.capacity = newCapacity;
        fFields.heap.ptr = newFields;
        fFields.heap.capacity = newCapacity;
        fZero = newZero;
        fLength += count;
    } else {
        int32_t newZero = oldCapacity / 2 - (fLength + count) / 2;

        // C++ note: memmove is required because src and dest may overlap.
        // First copy the entire string to the location of the prefix, and then move the suffix
        // to make room for the new chars that the caller wants to insert.
        uprv_memmove2(oldChars + newZero, oldChars + oldZero, sizeof(char16_t) * fLength);
        uprv_memmove2(oldChars + newZero + index + count,
                oldChars + newZero + index,
                sizeof(char16_t) * (fLength - index));
        uprv_memmove2(oldFields + newZero, oldFields + oldZero, sizeof(Field) * fLength);
        uprv_memmove2(oldFields + newZero + index + count,
                oldFields + newZero + index,
                sizeof(Field) * (fLength - index));

        fZero = newZero;
        fLength += count;
    }
    return fZero + index;
}

int32_t NumberStringBuilder::remove(int32_t index, int32_t count) {
    // TODO: Reset the heap here?  (If the string after removal can fit on stack?)
    int32_t position = index + fZero;
    uprv_memmove2(getCharPtr() + position,
            getCharPtr() + position + count,
            sizeof(char16_t) * (fLength - index - count));
    uprv_memmove2(getFieldPtr() + position,
            getFieldPtr() + position + count,
            sizeof(Field) * (fLength - index - count));
    fLength -= count;
    return position;
}

UnicodeString NumberStringBuilder::toUnicodeString() const {
    return UnicodeString(getCharPtr() + fZero, fLength);
}

const UnicodeString NumberStringBuilder::toTempUnicodeString() const {
    // Readonly-alias constructor:
    return UnicodeString(FALSE, getCharPtr() + fZero, fLength);
}

UnicodeString NumberStringBuilder::toDebugString() const {
    UnicodeString sb;
    sb.append(u"<NumberStringBuilder [", -1);
    sb.append(toUnicodeString());
    sb.append(u"] [", -1);
    for (int i = 0; i < fLength; i++) {
        if (fieldAt(i) == UNUM_FIELD_COUNT) {
            sb.append(u'n');
        } else {
            char16_t c;
            switch (fieldAt(i)) {
                case UNUM_SIGN_FIELD:
                    c = u'-';
                    break;
                case UNUM_INTEGER_FIELD:
                    c = u'i';
                    break;
                case UNUM_FRACTION_FIELD:
                    c = u'f';
                    break;
                case UNUM_EXPONENT_FIELD:
                    c = u'e';
                    break;
                case UNUM_EXPONENT_SIGN_FIELD:
                    c = u'+';
                    break;
                case UNUM_EXPONENT_SYMBOL_FIELD:
                    c = u'E';
                    break;
                case UNUM_DECIMAL_SEPARATOR_FIELD:
                    c = u'.';
                    break;
                case UNUM_GROUPING_SEPARATOR_FIELD:
                    c = u',';
                    break;
                case UNUM_PERCENT_FIELD:
                    c = u'%';
                    break;
                case UNUM_PERMILL_FIELD:
                    c = u'‰';
                    break;
                case UNUM_CURRENCY_FIELD:
                    c = u'$';
                    break;
                default:
                    c = u'?';
                    break;
            }
            sb.append(c);
        }
    }
    sb.append(u"]>", -1);
    return sb;
}

const char16_t *NumberStringBuilder::chars() const {
    return getCharPtr() + fZero;
}

bool NumberStringBuilder::contentEquals(const NumberStringBuilder &other) const {
    if (fLength != other.fLength) {
        return false;
    }
    for (int32_t i = 0; i < fLength; i++) {
        if (charAt(i) != other.charAt(i) || fieldAt(i) != other.fieldAt(i)) {
            return false;
        }
    }
    return true;
}

bool NumberStringBuilder::nextFieldPosition(FieldPosition& fp, UErrorCode& status) const {
    int32_t rawField = fp.getField();

    if (rawField == FieldPosition::DONT_CARE) {
        return FALSE;
    }

    if (rawField < 0 || rawField >= UNUM_FIELD_COUNT) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return FALSE;
    }

    auto field = static_cast<Field>(rawField);

    bool seenStart = false;
    int32_t fractionStart = -1;
    int32_t startIndex = fp.getEndIndex();
    for (int 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);
            break;
        } 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;
        }
    }

    // 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;
}

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.
            fpih.addAttribute(UNUM_GROUPING_SEPARATOR_FIELD, i, i + 1);
        } else if (current != field) {
            if (current != UNUM_FIELD_COUNT) {
                fpih.addAttribute(current, currentStart, i);
            }
            current = field;
            currentStart = i;
        }
        if (U_FAILURE(status)) {
            return;
        }
    }
    if (current != UNUM_FIELD_COUNT) {
        fpih.addAttribute(current, currentStart, fLength);
    }
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 A	1	// © 2017 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	#include "number_stringbuilder.h"
	9	#include "unicode/utf16.h"
	10
	11	using namespace icu;
	12	using namespace icu::number;
	13	using namespace icu::number::impl;
	14
	15	namespace {
	16
	17	// A version of uprv_memcpy that checks for length 0.
	18	// By default, uprv_memcpy requires a length of at least 1.
	19	inline void uprv_memcpy2(void* dest, const void* src, size_t len) {
	20	if (len > 0) {
	21	uprv_memcpy(dest, src, len);
	22	}
	23	}
	24
	25	// A version of uprv_memmove that checks for length 0.
	26	// By default, uprv_memmove requires a length of at least 1.
	27	inline void uprv_memmove2(void* dest, const void* src, size_t len) {
	28	if (len > 0) {
	29	uprv_memmove(dest, src, len);
	30	}
	31	}
	32
	33	} // namespace
	34
	35	NumberStringBuilder::NumberStringBuilder() = default;
	36
	37	NumberStringBuilder::~NumberStringBuilder() {
	38	if (fUsingHeap) {
	39	uprv_free(fChars.heap.ptr);
	40	uprv_free(fFields.heap.ptr);
	41	}
	42	}
	43
	44	NumberStringBuilder::NumberStringBuilder(const NumberStringBuilder &other) {
	45	*this = other;
	46	}
	47
	48	NumberStringBuilder &NumberStringBuilder::operator=(const NumberStringBuilder &other) {
	49	// Check for self-assignment
	50	if (this == &other) {
	51	return *this;
	52	}
	53
	54	// Continue with deallocation and copying
	55	if (fUsingHeap) {
	56	uprv_free(fChars.heap.ptr);
	57	uprv_free(fFields.heap.ptr);
	58	fUsingHeap = false;
	59	}
	60
	61	int32_t capacity = other.getCapacity();
	62	if (capacity > DEFAULT_CAPACITY) {
	63	// FIXME: uprv_malloc
	64	// C++ note: malloc appears in two places: here and in prepareForInsertHelper.
65	auto newChars = static_cast<char16_t > (uprv_malloc(sizeof(char16_t) capacity));
66	auto newFields = static_cast<Field >(uprv_malloc(sizeof(Field) capacity));
67	if (newChars == nullptr \|\| newFields == nullptr) {
68	// UErrorCode is not available; fail silently.
69	uprv_free(newChars);
70	uprv_free(newFields);
71	*this = NumberStringBuilder(); // can't fail
72	return *this;
73	}
74
75	fUsingHeap = true;
76	fChars.heap.capacity = capacity;
77	fChars.heap.ptr = newChars;
78	fFields.heap.capacity = capacity;
79	fFields.heap.ptr = newFields;
80	}
81
82	uprv_memcpy2(getCharPtr(), other.getCharPtr(), sizeof(char16_t) * capacity);
83	uprv_memcpy2(getFieldPtr(), other.getFieldPtr(), sizeof(Field) * capacity);
84
85	fZero = other.fZero;
86	fLength = other.fLength;
87	return *this;
88	}
89
90	int32_t NumberStringBuilder::length() const {
91	return fLength;
92	}
93
94	int32_t NumberStringBuilder::codePointCount() const {
95	return u_countChar32(getCharPtr() + fZero, fLength);
96	}
97
98	UChar32 NumberStringBuilder::getFirstCodePoint() const {
99	if (fLength == 0) {
100	return -1;
101	}
102	UChar32 cp;
103	U16_GET(getCharPtr() + fZero, 0, 0, fLength, cp);
104	return cp;
105	}
106
107	UChar32 NumberStringBuilder::getLastCodePoint() const {
108	if (fLength == 0) {
109	return -1;
110	}
111	int32_t offset = fLength;
112	U16_BACK_1(getCharPtr() + fZero, 0, offset);
113	UChar32 cp;
114	U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);
115	return cp;
116	}
117
118	UChar32 NumberStringBuilder::codePointAt(int32_t index) const {
119	UChar32 cp;
120	U16_GET(getCharPtr() + fZero, 0, index, fLength, cp);
121	return cp;
122	}
123
124	UChar32 NumberStringBuilder::codePointBefore(int32_t index) const {
125	int32_t offset = index;
126	U16_BACK_1(getCharPtr() + fZero, 0, offset);
127	UChar32 cp;
128	U16_GET(getCharPtr() + fZero, 0, offset, fLength, cp);
129	return cp;
130	}
131
132	NumberStringBuilder &NumberStringBuilder::clear() {
133	// TODO: Reset the heap here?
134	fZero = getCapacity() / 2;
135	fLength = 0;
136	return *this;
137	}
138
139	int32_t NumberStringBuilder::appendCodePoint(UChar32 codePoint, Field field, UErrorCode &status) {
140	return insertCodePoint(fLength, codePoint, field, status);
141	}
142
143	int32_t
144	NumberStringBuilder::insertCodePoint(int32_t index, UChar32 codePoint, Field field, UErrorCode &status) {
145	int32_t count = U16_LENGTH(codePoint);
146	int32_t position = prepareForInsert(index, count, status);
147	if (U_FAILURE(status)) {
148	return count;
149	}
150	if (count == 1) {
151	getCharPtr()[position] = (char16_t) codePoint;
152	getFieldPtr()[position] = field;
153	} else {
154	getCharPtr()[position] = U16_LEAD(codePoint);
155	getCharPtr()[position + 1] = U16_TRAIL(codePoint);
156	getFieldPtr()[position] = getFieldPtr()[position + 1] = field;
157	}
158	return count;
159	}
160
161	int32_t NumberStringBuilder::append(const UnicodeString &unistr, Field field, UErrorCode &status) {
162	return insert(fLength, unistr, field, status);
163	}
164
165	int32_t NumberStringBuilder::insert(int32_t index, const UnicodeString &unistr, Field field,
166	UErrorCode &status) {
167	if (unistr.length() == 0) {
168	// Nothing to insert.
169	return 0;
170	} else if (unistr.length() == 1) {
171	// Fast path: insert using insertCodePoint.
172	return insertCodePoint(index, unistr.charAt(0), field, status);
173	} else {
174	return insert(index, unistr, 0, unistr.length(), field, status);
175	}
176	}
177
178	int32_t
179	NumberStringBuilder::insert(int32_t index, const UnicodeString &unistr, int32_t start, int32_t end,
180	Field field, UErrorCode &status) {
181	int32_t count = end - start;
182	int32_t position = prepareForInsert(index, count, status);
183	if (U_FAILURE(status)) {
184	return count;
185	}
186	for (int32_t i = 0; i < count; i++) {
187	getCharPtr()[position + i] = unistr.charAt(start + i);
188	getFieldPtr()[position + i] = field;
189	}
190	return count;
191	}
192
193	int32_t
194	NumberStringBuilder::splice(int32_t startThis, int32_t endThis, const UnicodeString &unistr,
195	int32_t startOther, int32_t endOther, Field field, UErrorCode& status) {
196	int32_t thisLength = endThis - startThis;
197	int32_t otherLength = endOther - startOther;
198	int32_t count = otherLength - thisLength;
199	int32_t position;
200	if (count > 0) {
201	// Overall, chars need to be added.
202	position = prepareForInsert(startThis, count, status);
203	} else {
204	// Overall, chars need to be removed or kept the same.
205	position = remove(startThis, -count);
206	}
207	if (U_FAILURE(status)) {
208	return count;
209	}
210	for (int32_t i = 0; i < otherLength; i++) {
211	getCharPtr()[position + i] = unistr.charAt(startOther + i);
212	getFieldPtr()[position + i] = field;
213	}
214	return count;
215	}
216
217	int32_t NumberStringBuilder::append(const NumberStringBuilder &other, UErrorCode &status) {
218	return insert(fLength, other, status);
219	}
220
221	int32_t
222	NumberStringBuilder::insert(int32_t index, const NumberStringBuilder &other, UErrorCode &status) {
223	if (this == &other) {
224	status = U_ILLEGAL_ARGUMENT_ERROR;
225	return 0;
226	}
227	int32_t count = other.fLength;
228	if (count == 0) {
229	// Nothing to insert.
230	return 0;
231	}
232	int32_t position = prepareForInsert(index, count, status);
233	if (U_FAILURE(status)) {
234	return count;
235	}
236	for (int32_t i = 0; i < count; i++) {
237	getCharPtr()[position + i] = other.charAt(i);
238	getFieldPtr()[position + i] = other.fieldAt(i);
239	}
240	return count;
241	}
242
243	int32_t NumberStringBuilder::prepareForInsert(int32_t index, int32_t count, UErrorCode &status) {
244	if (index == 0 && fZero - count >= 0) {
245	// Append to start
246	fZero -= count;
247	fLength += count;
248	return fZero;
249	} else if (index == fLength && fZero + fLength + count < getCapacity()) {
250	// Append to end
251	fLength += count;
252	return fZero + fLength - count;
253	} else {
254	// Move chars around and/or allocate more space
255	return prepareForInsertHelper(index, count, status);
256	}
257	}
258
259	int32_t NumberStringBuilder::prepareForInsertHelper(int32_t index, int32_t count, UErrorCode &status) {
260	int32_t oldCapacity = getCapacity();
261	int32_t oldZero = fZero;
262	char16_t *oldChars = getCharPtr();
263	Field *oldFields = getFieldPtr();
264	if (fLength + count > oldCapacity) {
265	int32_t newCapacity = (fLength + count) * 2;
266	int32_t newZero = newCapacity / 2 - (fLength + count) / 2;
267
268	// C++ note: malloc appears in two places: here and in the assignment operator.
269	auto newChars = static_cast<char16_t > (uprv_malloc(sizeof(char16_t) newCapacity));
270	auto newFields = static_cast<Field >(uprv_malloc(sizeof(Field) newCapacity));
271	if (newChars == nullptr \|\| newFields == nullptr) {
272	uprv_free(newChars);
273	uprv_free(newFields);
274	status = U_MEMORY_ALLOCATION_ERROR;
275	return -1;
276	}
277
278	// First copy the prefix and then the suffix, leaving room for the new chars that the
279	// caller wants to insert.
280	// C++ note: memcpy is OK because the src and dest do not overlap.
281	uprv_memcpy2(newChars + newZero, oldChars + oldZero, sizeof(char16_t) * index);
282	uprv_memcpy2(newChars + newZero + index + count,
283	oldChars + oldZero + index,
284	sizeof(char16_t) * (fLength - index));
285	uprv_memcpy2(newFields + newZero, oldFields + oldZero, sizeof(Field) * index);
286	uprv_memcpy2(newFields + newZero + index + count,
287	oldFields + oldZero + index,
288	sizeof(Field) * (fLength - index));
289
290	if (fUsingHeap) {
291	uprv_free(oldChars);
292	uprv_free(oldFields);
293	}
294	fUsingHeap = true;
295	fChars.heap.ptr = newChars;
296	fChars.heap.capacity = newCapacity;
297	fFields.heap.ptr = newFields;
298	fFields.heap.capacity = newCapacity;
299	fZero = newZero;
300	fLength += count;
301	} else {
302	int32_t newZero = oldCapacity / 2 - (fLength + count) / 2;
303
304	// C++ note: memmove is required because src and dest may overlap.
305	// First copy the entire string to the location of the prefix, and then move the suffix
306	// to make room for the new chars that the caller wants to insert.
307	uprv_memmove2(oldChars + newZero, oldChars + oldZero, sizeof(char16_t) * fLength);
308	uprv_memmove2(oldChars + newZero + index + count,
309	oldChars + newZero + index,
310	sizeof(char16_t) * (fLength - index));
311	uprv_memmove2(oldFields + newZero, oldFields + oldZero, sizeof(Field) * fLength);
312	uprv_memmove2(oldFields + newZero + index + count,
313	oldFields + newZero + index,
314	sizeof(Field) * (fLength - index));
315
316	fZero = newZero;
317	fLength += count;
318	}
319	return fZero + index;
320	}
321
322	int32_t NumberStringBuilder::remove(int32_t index, int32_t count) {
323	// TODO: Reset the heap here? (If the string after removal can fit on stack?)
324	int32_t position = index + fZero;
325	uprv_memmove2(getCharPtr() + position,
326	getCharPtr() + position + count,
327	sizeof(char16_t) * (fLength - index - count));
328	uprv_memmove2(getFieldPtr() + position,
329	getFieldPtr() + position + count,
330	sizeof(Field) * (fLength - index - count));
331	fLength -= count;
332	return position;
333	}
334
335	UnicodeString NumberStringBuilder::toUnicodeString() const {
336	return UnicodeString(getCharPtr() + fZero, fLength);
337	}
338
339	const UnicodeString NumberStringBuilder::toTempUnicodeString() const {
340	// Readonly-alias constructor:
341	return UnicodeString(FALSE, getCharPtr() + fZero, fLength);
342	}
343
344	UnicodeString NumberStringBuilder::toDebugString() const {
345	UnicodeString sb;
346	sb.append(u"<NumberStringBuilder [", -1);
347	sb.append(toUnicodeString());
348	sb.append(u"] [", -1);
349	for (int i = 0; i < fLength; i++) {
350	if (fieldAt(i) == UNUM_FIELD_COUNT) {
351	sb.append(u'n');
352	} else {
353	char16_t c;
354	switch (fieldAt(i)) {
355	case UNUM_SIGN_FIELD:
356	c = u'-';
357	break;
358	case UNUM_INTEGER_FIELD:
359	c = u'i';
360	break;
361	case UNUM_FRACTION_FIELD:
362	c = u'f';
363	break;
364	case UNUM_EXPONENT_FIELD:
365	c = u'e';
366	break;
367	case UNUM_EXPONENT_SIGN_FIELD:
368	c = u'+';
369	break;
370	case UNUM_EXPONENT_SYMBOL_FIELD:
371	c = u'E';
372	break;
373	case UNUM_DECIMAL_SEPARATOR_FIELD:
374	c = u'.';
375	break;
376	case UNUM_GROUPING_SEPARATOR_FIELD:
377	c = u',';
378	break;
379	case UNUM_PERCENT_FIELD:
380	c = u'%';
381	break;
382	case UNUM_PERMILL_FIELD:
383	c = u'‰';
384	break;
385	case UNUM_CURRENCY_FIELD:
386	c = u'$';
387	break;
388	default:
389	c = u'?';
390	break;
391	}
392	sb.append(c);
393	}
394	}
395	sb.append(u"]>", -1);
396	return sb;
397	}
398
399	const char16_t *NumberStringBuilder::chars() const {
400	return getCharPtr() + fZero;
401	}
402
403	bool NumberStringBuilder::contentEquals(const NumberStringBuilder &other) const {
404	if (fLength != other.fLength) {
405	return false;
406	}
407	for (int32_t i = 0; i < fLength; i++) {
408	if (charAt(i) != other.charAt(i) \|\| fieldAt(i) != other.fieldAt(i)) {
409	return false;
410	}
411	}
412	return true;
413	}
414
415	bool NumberStringBuilder::nextFieldPosition(FieldPosition& fp, UErrorCode& status) const {
416	int32_t rawField = fp.getField();
417
418	if (rawField == FieldPosition::DONT_CARE) {
419	return FALSE;
420	}
421
422	if (rawField < 0 \|\| rawField >= UNUM_FIELD_COUNT) {
423	status = U_ILLEGAL_ARGUMENT_ERROR;
424	return FALSE;
425	}
426
427	auto field = static_cast<Field>(rawField);
428
429	bool seenStart = false;
430	int32_t fractionStart = -1;
431	int32_t startIndex = fp.getEndIndex();
432	for (int i = fZero + startIndex; i <= fZero + fLength; i++) {
433	Field _field = UNUM_FIELD_COUNT;
434	if (i < fZero + fLength) {
435	_field = getFieldPtr()[i];
436	}
437	if (seenStart && field != _field) {
438	// Special case: GROUPING_SEPARATOR counts as an INTEGER.
439	if (field == UNUM_INTEGER_FIELD && _field == UNUM_GROUPING_SEPARATOR_FIELD) {
440	continue;
441	}
442	fp.setEndIndex(i - fZero);
443	break;
444	} else if (!seenStart && field == _field) {
445	fp.setBeginIndex(i - fZero);
446	seenStart = true;
447	}
448	if (_field == UNUM_INTEGER_FIELD \|\| _field == UNUM_DECIMAL_SEPARATOR_FIELD) {
449	fractionStart = i - fZero + 1;
450	}
451	}
452
453	// Backwards compatibility: FRACTION needs to start after INTEGER if empty.
454	// Do not return that a field was found, though, since there is not actually a fraction part.
455	if (field == UNUM_FRACTION_FIELD && !seenStart && fractionStart != -1) {
456	fp.setBeginIndex(fractionStart);
457	fp.setEndIndex(fractionStart);
458	}
459
460	return seenStart;
461	}
462
463	void NumberStringBuilder::getAllFieldPositions(FieldPositionIteratorHandler& fpih,
464	UErrorCode& status) const {
465	Field current = UNUM_FIELD_COUNT;
466	int32_t currentStart = -1;
467	for (int32_t i = 0; i < fLength; i++) {
468	Field field = fieldAt(i);
469	if (current == UNUM_INTEGER_FIELD && field == UNUM_GROUPING_SEPARATOR_FIELD) {
470	// Special case: GROUPING_SEPARATOR counts as an INTEGER.
471	fpih.addAttribute(UNUM_GROUPING_SEPARATOR_FIELD, i, i + 1);
472	} else if (current != field) {
473	if (current != UNUM_FIELD_COUNT) {
474	fpih.addAttribute(current, currentStart, i);
475	}
476	current = field;
477	currentStart = i;
478	}
479	if (U_FAILURE(status)) {
480	return;
481	}
482	}
483	if (current != UNUM_FIELD_COUNT) {
484	fpih.addAttribute(current, currentStart, fLength);
485	}
486	}
487
488	#endif /* #if !UCONFIG_NO_FORMATTING */