1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
// © 2025 and later: Unicode, Inc. and others.
// License & terms of use: https://www.unicode.org/copyright.html
#ifndef FIXEDSTRING_H
#define FIXEDSTRING_H
#include <string_view>
#include <utility>
#include "unicode/uobject.h"
#include "unicode/utypes.h"
#include "cmemory.h"
U_NAMESPACE_BEGIN
class UnicodeString;
/**
* ICU-internal fixed-length char* string class.
* This is a complement to CharString to store fixed-length strings efficiently
* (not allocating any unnecessary storage for future additions to the string).
*
* A terminating NUL is always stored, but the length of the string isn't.
* An empty string is stored as nullptr, allocating no storage at all.
*
* This class wants to be convenient but is also deliberately minimalist.
* Please do not add methods if they only add minor convenience.
*/
class FixedString : public UMemory {
public:
FixedString() = default;
~FixedString() { operator delete[](ptr); }
FixedString(const FixedString& other) : FixedString(other.data()) {}
FixedString(std::string_view init) {
size_t size = init.size();
if (size > 0 && reserve(size + 1)) {
uprv_memcpy(ptr, init.data(), size);
ptr[size] = '\0';
}
}
FixedString& operator=(const FixedString& other) {
*this = other.data();
return *this;
}
FixedString& operator=(std::string_view init) {
if (init.empty()) {
operator delete[](ptr);
ptr = nullptr;
} else {
size_t size = init.size();
if (reserve(size + 1)) {
uprv_memcpy(ptr, init.data(), size);
ptr[size] = '\0';
}
}
return *this;
}
FixedString(FixedString&& other) noexcept : ptr(std::exchange(other.ptr, nullptr)) {}
FixedString& operator=(FixedString&& other) noexcept {
operator delete[](ptr);
ptr = other.ptr;
other.ptr = nullptr;
return *this;
}
void clear() {
operator delete[](ptr);
ptr = nullptr;
}
const char* data() const {
return isEmpty() ? "" : ptr;
}
char* getAlias() {
return ptr;
}
bool isEmpty() const {
return ptr == nullptr;
}
/** Allocate storage for a new string, without initializing it. */
bool reserve(size_t size) {
operator delete[](ptr);
ptr = static_cast<char*>(operator new[](size));
return ptr != nullptr;
}
private:
char* ptr = nullptr;
};
U_COMMON_API void copyInvariantChars(const UnicodeString& src, FixedString& dst, UErrorCode& status);
U_NAMESPACE_END
#endif
|
