1 /*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #ifndef SkString_DEFINED
9 #define SkString_DEFINED
10
11 #include "include/core/SkRefCnt.h"
12 #include "include/core/SkScalar.h"
13 #include "include/core/SkTypes.h"
14 #include "include/private/base/SkTo.h"
15 #include "include/private/base/SkTypeTraits.h"
16
17 #include <atomic>
18 #include <cstdarg>
19 #include <cstdint>
20 #include <cstring>
21 #include <string>
22 #include <string_view>
23 #include <type_traits>
24
25 /* Some helper functions for C strings */
SkStrStartsWith(const char string[],const char prefixStr[])26 static inline bool SkStrStartsWith(const char string[], const char prefixStr[]) {
27 SkASSERT(string);
28 SkASSERT(prefixStr);
29 return !strncmp(string, prefixStr, strlen(prefixStr));
30 }
SkStrStartsWith(const char string[],const char prefixChar)31 static inline bool SkStrStartsWith(const char string[], const char prefixChar) {
32 SkASSERT(string);
33 return (prefixChar == *string);
34 }
35
36 bool SkStrEndsWith(const char string[], const char suffixStr[]);
37 bool SkStrEndsWith(const char string[], const char suffixChar);
38
39 int SkStrStartsWithOneOf(const char string[], const char prefixes[]);
40
SkStrFind(const char string[],const char substring[])41 static inline int SkStrFind(const char string[], const char substring[]) {
42 const char *first = strstr(string, substring);
43 if (nullptr == first) return -1;
44 return SkToInt(first - &string[0]);
45 }
46
SkStrFindLastOf(const char string[],const char subchar)47 static inline int SkStrFindLastOf(const char string[], const char subchar) {
48 const char* last = strrchr(string, subchar);
49 if (nullptr == last) return -1;
50 return SkToInt(last - &string[0]);
51 }
52
SkStrContains(const char string[],const char substring[])53 static inline bool SkStrContains(const char string[], const char substring[]) {
54 SkASSERT(string);
55 SkASSERT(substring);
56 return (-1 != SkStrFind(string, substring));
57 }
SkStrContains(const char string[],const char subchar)58 static inline bool SkStrContains(const char string[], const char subchar) {
59 SkASSERT(string);
60 char tmp[2];
61 tmp[0] = subchar;
62 tmp[1] = '\0';
63 return (-1 != SkStrFind(string, tmp));
64 }
65
66 /*
67 * The SkStrAppend... methods will write into the provided buffer, assuming it is large enough.
68 * Each method has an associated const (e.g. kSkStrAppendU32_MaxSize) which will be the largest
69 * value needed for that method's buffer.
70 *
71 * char storage[kSkStrAppendU32_MaxSize];
72 * SkStrAppendU32(storage, value);
73 *
74 * Note : none of the SkStrAppend... methods write a terminating 0 to their buffers. Instead,
75 * the methods return the ptr to the end of the written part of the buffer. This can be used
76 * to compute the length, and/or know where to write a 0 if that is desired.
77 *
78 * char storage[kSkStrAppendU32_MaxSize + 1];
79 * char* stop = SkStrAppendU32(storage, value);
80 * size_t len = stop - storage;
81 * *stop = 0; // valid, since storage was 1 byte larger than the max.
82 */
83
84 static constexpr int kSkStrAppendU32_MaxSize = 10;
85 char* SkStrAppendU32(char buffer[], uint32_t);
86 static constexpr int kSkStrAppendU64_MaxSize = 20;
87 char* SkStrAppendU64(char buffer[], uint64_t, int minDigits);
88
89 static constexpr int kSkStrAppendS32_MaxSize = kSkStrAppendU32_MaxSize + 1;
90 char* SkStrAppendS32(char buffer[], int32_t);
91 static constexpr int kSkStrAppendS64_MaxSize = kSkStrAppendU64_MaxSize + 1;
92 char* SkStrAppendS64(char buffer[], int64_t, int minDigits);
93
94 /**
95 * Floats have at most 8 significant digits, so we limit our %g to that.
96 * However, the total string could be 15 characters: -1.2345678e-005
97 *
98 * In theory we should only expect up to 2 digits for the exponent, but on
99 * some platforms we have seen 3 (as in the example above).
100 */
101 static constexpr int kSkStrAppendScalar_MaxSize = 15;
102
103 /**
104 * Write the scalar in decimal format into buffer, and return a pointer to
105 * the next char after the last one written. Note: a terminating 0 is not
106 * written into buffer, which must be at least kSkStrAppendScalar_MaxSize.
107 * Thus if the caller wants to add a 0 at the end, buffer must be at least
108 * kSkStrAppendScalar_MaxSize + 1 bytes large.
109 */
110 char* SkStrAppendScalar(char buffer[], SkScalar);
111
112 /** \class SkString
113
114 Light weight class for managing strings. Uses reference
115 counting to make string assignments and copies very fast
116 with no extra RAM cost. Assumes UTF8 encoding.
117 */
118 class SK_API SkString {
119 public:
120 SkString();
121 explicit SkString(size_t len);
122 explicit SkString(const char text[]);
123 SkString(const char text[], size_t len);
124 SkString(const SkString&);
125 SkString(SkString&&);
126 explicit SkString(const std::string&);
127 explicit SkString(std::string_view);
128 ~SkString();
129
isEmpty()130 bool isEmpty() const { return 0 == fRec->fLength; }
size()131 size_t size() const { return (size_t) fRec->fLength; }
data()132 const char* data() const { return fRec->data(); }
c_str()133 const char* c_str() const { return fRec->data(); }
134 char operator[](size_t n) const { return this->c_str()[n]; }
135
136 bool equals(const SkString&) const;
137 bool equals(const char text[]) const;
138 bool equals(const char text[], size_t len) const;
139
startsWith(const char prefixStr[])140 bool startsWith(const char prefixStr[]) const {
141 return SkStrStartsWith(fRec->data(), prefixStr);
142 }
startsWith(const char prefixChar)143 bool startsWith(const char prefixChar) const {
144 return SkStrStartsWith(fRec->data(), prefixChar);
145 }
endsWith(const char suffixStr[])146 bool endsWith(const char suffixStr[]) const {
147 return SkStrEndsWith(fRec->data(), suffixStr);
148 }
endsWith(const char suffixChar)149 bool endsWith(const char suffixChar) const {
150 return SkStrEndsWith(fRec->data(), suffixChar);
151 }
contains(const char substring[])152 bool contains(const char substring[]) const {
153 return SkStrContains(fRec->data(), substring);
154 }
contains(const char subchar)155 bool contains(const char subchar) const {
156 return SkStrContains(fRec->data(), subchar);
157 }
find(const char substring[])158 int find(const char substring[]) const {
159 return SkStrFind(fRec->data(), substring);
160 }
findLastOf(const char subchar)161 int findLastOf(const char subchar) const {
162 return SkStrFindLastOf(fRec->data(), subchar);
163 }
164
165 friend bool operator==(const SkString& a, const SkString& b) {
166 return a.equals(b);
167 }
168 friend bool operator!=(const SkString& a, const SkString& b) {
169 return !a.equals(b);
170 }
171
172 // these methods edit the string
173
174 SkString& operator=(const SkString&);
175 SkString& operator=(SkString&&);
176 SkString& operator=(const char text[]);
177
178 char* data();
179 char& operator[](size_t n) { return this->data()[n]; }
180
181 void reset();
182 /** String contents are preserved on resize. (For destructive resize, `set(nullptr, length)`.)
183 * `resize` automatically reserves an extra byte at the end of the buffer for a null terminator.
184 */
185 void resize(size_t len);
set(const SkString & src)186 void set(const SkString& src) { *this = src; }
187 void set(const char text[]);
188 void set(const char text[], size_t len);
set(std::string_view str)189 void set(std::string_view str) { this->set(str.data(), str.size()); }
190
191 void insert(size_t offset, const char text[]);
192 void insert(size_t offset, const char text[], size_t len);
insert(size_t offset,const SkString & str)193 void insert(size_t offset, const SkString& str) { this->insert(offset, str.c_str(), str.size()); }
insert(size_t offset,std::string_view str)194 void insert(size_t offset, std::string_view str) { this->insert(offset, str.data(), str.size()); }
195 void insertUnichar(size_t offset, SkUnichar);
196 void insertS32(size_t offset, int32_t value);
197 void insertS64(size_t offset, int64_t value, int minDigits = 0);
198 void insertU32(size_t offset, uint32_t value);
199 void insertU64(size_t offset, uint64_t value, int minDigits = 0);
200 void insertHex(size_t offset, uint32_t value, int minDigits = 0);
201 void insertScalar(size_t offset, SkScalar);
202
append(const char text[])203 void append(const char text[]) { this->insert((size_t)-1, text); }
append(const char text[],size_t len)204 void append(const char text[], size_t len) { this->insert((size_t)-1, text, len); }
append(const SkString & str)205 void append(const SkString& str) { this->insert((size_t)-1, str.c_str(), str.size()); }
append(std::string_view str)206 void append(std::string_view str) { this->insert((size_t)-1, str.data(), str.size()); }
appendUnichar(SkUnichar uni)207 void appendUnichar(SkUnichar uni) { this->insertUnichar((size_t)-1, uni); }
appendS32(int32_t value)208 void appendS32(int32_t value) { this->insertS32((size_t)-1, value); }
209 void appendS64(int64_t value, int minDigits = 0) { this->insertS64((size_t)-1, value, minDigits); }
appendU32(uint32_t value)210 void appendU32(uint32_t value) { this->insertU32((size_t)-1, value); }
211 void appendU64(uint64_t value, int minDigits = 0) { this->insertU64((size_t)-1, value, minDigits); }
212 void appendHex(uint32_t value, int minDigits = 0) { this->insertHex((size_t)-1, value, minDigits); }
appendScalar(SkScalar value)213 void appendScalar(SkScalar value) { this->insertScalar((size_t)-1, value); }
214
prepend(const char text[])215 void prepend(const char text[]) { this->insert(0, text); }
prepend(const char text[],size_t len)216 void prepend(const char text[], size_t len) { this->insert(0, text, len); }
prepend(const SkString & str)217 void prepend(const SkString& str) { this->insert(0, str.c_str(), str.size()); }
prepend(std::string_view str)218 void prepend(std::string_view str) { this->insert(0, str.data(), str.size()); }
prependUnichar(SkUnichar uni)219 void prependUnichar(SkUnichar uni) { this->insertUnichar(0, uni); }
prependS32(int32_t value)220 void prependS32(int32_t value) { this->insertS32(0, value); }
221 void prependS64(int32_t value, int minDigits = 0) { this->insertS64(0, value, minDigits); }
222 void prependHex(uint32_t value, int minDigits = 0) { this->insertHex(0, value, minDigits); }
prependScalar(SkScalar value)223 void prependScalar(SkScalar value) { this->insertScalar((size_t)-1, value); }
224
225 void printf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
226 void printVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
227 void appendf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
228 void appendVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
229 void prependf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
230 void prependVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
231
232 void remove(size_t offset, size_t length);
233
234 SkString& operator+=(const SkString& s) { this->append(s); return *this; }
235 SkString& operator+=(const char text[]) { this->append(text); return *this; }
236 SkString& operator+=(const char c) { this->append(&c, 1); return *this; }
237
238 /**
239 * Swap contents between this and other. This function is guaranteed
240 * to never fail or throw.
241 */
242 void swap(SkString& other);
243
244 using sk_is_trivially_relocatable = std::true_type;
245
246 private:
247 struct Rec {
248 public:
RecRec249 constexpr Rec(uint32_t len, int32_t refCnt) : fLength(len), fRefCnt(refCnt) {}
250 static sk_sp<Rec> Make(const char text[], size_t len);
dataRec251 char* data() { return fBeginningOfData; }
dataRec252 const char* data() const { return fBeginningOfData; }
253 void ref() const;
254 void unref() const;
255 bool unique() const;
256 #ifdef SK_DEBUG
257 int32_t getRefCnt() const;
258 #endif
259 uint32_t fLength; // logically size_t, but we want it to stay 32 bits
260
261 private:
262 mutable std::atomic<int32_t> fRefCnt;
263 char fBeginningOfData[1] = {'\0'};
264
265 // Ensure the unsized delete is called.
deleteRec266 void operator delete(void* p) { ::operator delete(p); }
267 };
268 sk_sp<Rec> fRec;
269
270 static_assert(::sk_is_trivially_relocatable<decltype(fRec)>::value);
271
272 #ifdef SK_DEBUG
273 SkString& validate();
274 const SkString& validate() const;
275 #else
validate()276 SkString& validate() { return *this; }
validate()277 const SkString& validate() const { return *this; }
278 #endif
279
280 static const Rec gEmptyRec;
281 };
282
283 /// Creates a new string and writes into it using a printf()-style format.
284 SK_API SkString SkStringPrintf(const char* format, ...) SK_PRINTF_LIKE(1, 2);
285 /// This makes it easier to write a caller as a VAR_ARGS function where the format string is
286 /// optional.
SkStringPrintf()287 static inline SkString SkStringPrintf() { return SkString(); }
288
swap(SkString & a,SkString & b)289 static inline void swap(SkString& a, SkString& b) {
290 a.swap(b);
291 }
292
293 #endif
294