ikan Uploader :
Directory : /proc/self/root/home/ubuntu/node-v16.18.1/deps/icu-small/source/i18n/
Upload File : |
| Current File : //proc/self/root/home/ubuntu/node-v16.18.1/deps/icu-small/source/i18n/formatted_string_builder.h |
// © 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
#ifndef __NUMBER_STRINGBUILDER_H__
#define __NUMBER_STRINGBUILDER_H__
#include <cstdint>
#include <type_traits>
#include "cstring.h"
#include "uassert.h"
#include "fphdlimp.h"
U_NAMESPACE_BEGIN
class FormattedValueStringBuilderImpl;
/**
* A StringBuilder optimized for formatting. It implements the following key
* features beyond a UnicodeString:
*
* <ol>
* <li>Efficient prepend as well as append.
* <li>Keeps track of Fields in an efficient manner.
* </ol>
*
* See also FormattedValueStringBuilderImpl.
*
* @author sffc (Shane Carr)
*/
class U_I18N_API FormattedStringBuilder : public UMemory {
private:
static const int32_t DEFAULT_CAPACITY = 40;
template<typename T>
union ValueOrHeapArray {
T value[DEFAULT_CAPACITY];
struct {
T *ptr;
int32_t capacity;
} heap;
};
public:
FormattedStringBuilder();
~FormattedStringBuilder();
FormattedStringBuilder(const FormattedStringBuilder &other);
// Convention: bottom 4 bits for field, top 4 bits for field category.
// Field category 0 implies the number category so that the number field
// literals can be directly passed as a Field type.
// Exported as U_I18N_API so it can be used by other exports on Windows.
struct U_I18N_API Field {
uint8_t bits;
Field() = default;
constexpr Field(uint8_t category, uint8_t field);
inline UFieldCategory getCategory() const;
inline int32_t getField() const;
inline bool isNumeric() const;
inline bool isUndefined() const;
inline bool operator==(const Field& other) const;
inline bool operator!=(const Field& other) const;
};
FormattedStringBuilder &operator=(const FormattedStringBuilder &other);
int32_t length() const;
int32_t codePointCount() const;
inline char16_t charAt(int32_t index) const {
U_ASSERT(index >= 0);
U_ASSERT(index < fLength);
return getCharPtr()[fZero + index];
}
inline Field fieldAt(int32_t index) const {
U_ASSERT(index >= 0);
U_ASSERT(index < fLength);
return getFieldPtr()[fZero + index];
}
UChar32 getFirstCodePoint() const;
UChar32 getLastCodePoint() const;
UChar32 codePointAt(int32_t index) const;
UChar32 codePointBefore(int32_t index) const;
FormattedStringBuilder &clear();
/** Appends a UTF-16 code unit. */
inline int32_t appendChar16(char16_t codeUnit, Field field, UErrorCode& status) {
// appendCodePoint handles both code units and code points.
return insertCodePoint(fLength, codeUnit, field, status);
}
/** Inserts a UTF-16 code unit. Note: insert at index 0 is very efficient. */
inline int32_t insertChar16(int32_t index, char16_t codeUnit, Field field, UErrorCode& status) {
// insertCodePoint handles both code units and code points.
return insertCodePoint(index, codeUnit, field, status);
}
/** Appends a Unicode code point. */
inline int32_t appendCodePoint(UChar32 codePoint, Field field, UErrorCode &status) {
return insertCodePoint(fLength, codePoint, field, status);
}
/** Inserts a Unicode code point. Note: insert at index 0 is very efficient. */
int32_t insertCodePoint(int32_t index, UChar32 codePoint, Field field, UErrorCode &status);
/** Appends a string. */
inline int32_t append(const UnicodeString &unistr, Field field, UErrorCode &status) {
return insert(fLength, unistr, field, status);
}
/** Inserts a string. Note: insert at index 0 is very efficient. */
int32_t insert(int32_t index, const UnicodeString &unistr, Field field, UErrorCode &status);
/** Inserts a substring. Note: insert at index 0 is very efficient.
*
* @param start Start index of the substring of unistr to be inserted.
* @param end End index of the substring of unistr to be inserted (exclusive).
*/
int32_t insert(int32_t index, const UnicodeString &unistr, int32_t start, int32_t end, Field field,
UErrorCode &status);
/** Deletes a substring and then inserts a string at that same position.
* Similar to JavaScript Array.prototype.splice().
*
* @param startThis Start of the span to delete.
* @param endThis End of the span to delete (exclusive).
* @param unistr The string to insert at the deletion position.
* @param startOther Start index of the substring of unistr to be inserted.
* @param endOther End index of the substring of unistr to be inserted (exclusive).
*/
int32_t splice(int32_t startThis, int32_t endThis, const UnicodeString &unistr,
int32_t startOther, int32_t endOther, Field field, UErrorCode& status);
/** Appends a formatted string. */
int32_t append(const FormattedStringBuilder &other, UErrorCode &status);
/** Inserts a formatted string. Note: insert at index 0 is very efficient. */
int32_t insert(int32_t index, const FormattedStringBuilder &other, UErrorCode &status);
/**
* Ensures that the string buffer contains a NUL terminator. The NUL terminator does
* not count toward the string length. Any further changes to the string (insert or
* append) may invalidate the NUL terminator.
*
* You should call this method after the formatted string is completely built if you
* plan to return a pointer to the string from a C API.
*/
void writeTerminator(UErrorCode& status);
/**
* Gets a "safe" UnicodeString that can be used even after the FormattedStringBuilder is destructed.
*/
UnicodeString toUnicodeString() const;
/**
* Gets an "unsafe" UnicodeString that is valid only as long as the FormattedStringBuilder is alive and
* unchanged. Slightly faster than toUnicodeString().
*/
const UnicodeString toTempUnicodeString() const;
UnicodeString toDebugString() const;
const char16_t *chars() const;
bool contentEquals(const FormattedStringBuilder &other) const;
bool containsField(Field field) const;
private:
bool fUsingHeap = false;
ValueOrHeapArray<char16_t> fChars;
ValueOrHeapArray<Field> fFields;
int32_t fZero = DEFAULT_CAPACITY / 2;
int32_t fLength = 0;
inline char16_t *getCharPtr() {
return fUsingHeap ? fChars.heap.ptr : fChars.value;
}
inline const char16_t *getCharPtr() const {
return fUsingHeap ? fChars.heap.ptr : fChars.value;
}
inline Field *getFieldPtr() {
return fUsingHeap ? fFields.heap.ptr : fFields.value;
}
inline const Field *getFieldPtr() const {
return fUsingHeap ? fFields.heap.ptr : fFields.value;
}
inline int32_t getCapacity() const {
return fUsingHeap ? fChars.heap.capacity : DEFAULT_CAPACITY;
}
int32_t prepareForInsert(int32_t index, int32_t count, UErrorCode &status);
int32_t prepareForInsertHelper(int32_t index, int32_t count, UErrorCode &status);
int32_t remove(int32_t index, int32_t count);
friend class FormattedValueStringBuilderImpl;
};
static_assert(
std::is_pod<FormattedStringBuilder::Field>::value,
"Field should be a POD type for efficient initialization");
constexpr FormattedStringBuilder::Field::Field(uint8_t category, uint8_t field)
: bits((
U_ASSERT(category <= 0xf),
U_ASSERT(field <= 0xf),
static_cast<uint8_t>((category << 4) | field)
)) {}
/**
* Internal constant for the undefined field for use in FormattedStringBuilder.
*/
constexpr FormattedStringBuilder::Field kUndefinedField = {UFIELD_CATEGORY_UNDEFINED, 0};
/**
* Internal field to signal "numeric" when fields are not supported in NumberFormat.
*/
constexpr FormattedStringBuilder::Field kGeneralNumericField = {UFIELD_CATEGORY_UNDEFINED, 1};
inline UFieldCategory FormattedStringBuilder::Field::getCategory() const {
return static_cast<UFieldCategory>(bits >> 4);
}
inline int32_t FormattedStringBuilder::Field::getField() const {
return bits & 0xf;
}
inline bool FormattedStringBuilder::Field::isNumeric() const {
return getCategory() == UFIELD_CATEGORY_NUMBER || *this == kGeneralNumericField;
}
inline bool FormattedStringBuilder::Field::isUndefined() const {
return getCategory() == UFIELD_CATEGORY_UNDEFINED;
}
inline bool FormattedStringBuilder::Field::operator==(const Field& other) const {
return bits == other.bits;
}
inline bool FormattedStringBuilder::Field::operator!=(const Field& other) const {
return bits != other.bits;
}
U_NAMESPACE_END
#endif //__NUMBER_STRINGBUILDER_H__
#endif /* #if !UCONFIG_NO_FORMATTING */
Kontol Shell Bypass