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]; }
begin()135 const char* begin() const { return data(); }
end()136 const char* end() const { return data() + size(); }
137
138 bool equals(const SkString&) const;
139 bool equals(const char text[]) const;
140 bool equals(const char text[], size_t len) const;
141
startsWith(const char prefixStr[])142 bool startsWith(const char prefixStr[]) const {
143 return SkStrStartsWith(fRec->data(), prefixStr);
144 }
startsWith(const char prefixChar)145 bool startsWith(const char prefixChar) const {
146 return SkStrStartsWith(fRec->data(), prefixChar);
147 }
endsWith(const char suffixStr[])148 bool endsWith(const char suffixStr[]) const {
149 return SkStrEndsWith(fRec->data(), suffixStr);
150 }
endsWith(const char suffixChar)151 bool endsWith(const char suffixChar) const {
152 return SkStrEndsWith(fRec->data(), suffixChar);
153 }
contains(const char substring[])154 bool contains(const char substring[]) const {
155 return SkStrContains(fRec->data(), substring);
156 }
contains(const char subchar)157 bool contains(const char subchar) const {
158 return SkStrContains(fRec->data(), subchar);
159 }
find(const char substring[])160 int find(const char substring[]) const {
161 return SkStrFind(fRec->data(), substring);
162 }
findLastOf(const char subchar)163 int findLastOf(const char subchar) const {
164 return SkStrFindLastOf(fRec->data(), subchar);
165 }
166
167 friend bool operator==(const SkString& a, const SkString& b) {
168 return a.equals(b);
169 }
170 friend bool operator!=(const SkString& a, const SkString& b) {
171 return !a.equals(b);
172 }
173
174 // these methods edit the string
175
176 SkString& operator=(const SkString&);
177 SkString& operator=(SkString&&);
178 SkString& operator=(const char text[]);
179
180 char* data();
181 char& operator[](size_t n) { return this->data()[n]; }
begin()182 char* begin() { return data(); }
end()183 char* end() { return data() + size(); }
184
185 void reset();
186 /** String contents are preserved on resize. (For destructive resize, `set(nullptr, length)`.)
187 * `resize` automatically reserves an extra byte at the end of the buffer for a null terminator.
188 */
189 void resize(size_t len);
set(const SkString & src)190 void set(const SkString& src) { *this = src; }
191 void set(const char text[]);
192 void set(const char text[], size_t len);
set(std::string_view str)193 void set(std::string_view str) { this->set(str.data(), str.size()); }
194
195 void insert(size_t offset, const char text[]);
196 void insert(size_t offset, const char text[], size_t len);
insert(size_t offset,const SkString & str)197 void insert(size_t offset, const SkString& str) { this->insert(offset, str.c_str(), str.size()); }
insert(size_t offset,std::string_view str)198 void insert(size_t offset, std::string_view str) { this->insert(offset, str.data(), str.size()); }
199 void insertUnichar(size_t offset, SkUnichar);
200 void insertS32(size_t offset, int32_t value);
201 void insertS64(size_t offset, int64_t value, int minDigits = 0);
202 void insertU32(size_t offset, uint32_t value);
203 void insertU64(size_t offset, uint64_t value, int minDigits = 0);
204 void insertHex(size_t offset, uint32_t value, int minDigits = 0);
205 void insertScalar(size_t offset, SkScalar);
206
append(const char text[])207 void append(const char text[]) { this->insert((size_t)-1, text); }
append(const char text[],size_t len)208 void append(const char text[], size_t len) { this->insert((size_t)-1, text, len); }
append(const SkString & str)209 void append(const SkString& str) { this->insert((size_t)-1, str.c_str(), str.size()); }
append(std::string_view str)210 void append(std::string_view str) { this->insert((size_t)-1, str.data(), str.size()); }
appendUnichar(SkUnichar uni)211 void appendUnichar(SkUnichar uni) { this->insertUnichar((size_t)-1, uni); }
appendS32(int32_t value)212 void appendS32(int32_t value) { this->insertS32((size_t)-1, value); }
213 void appendS64(int64_t value, int minDigits = 0) { this->insertS64((size_t)-1, value, minDigits); }
appendU32(uint32_t value)214 void appendU32(uint32_t value) { this->insertU32((size_t)-1, value); }
215 void appendU64(uint64_t value, int minDigits = 0) { this->insertU64((size_t)-1, value, minDigits); }
216 void appendHex(uint32_t value, int minDigits = 0) { this->insertHex((size_t)-1, value, minDigits); }
appendScalar(SkScalar value)217 void appendScalar(SkScalar value) { this->insertScalar((size_t)-1, value); }
218
prepend(const char text[])219 void prepend(const char text[]) { this->insert(0, text); }
prepend(const char text[],size_t len)220 void prepend(const char text[], size_t len) { this->insert(0, text, len); }
prepend(const SkString & str)221 void prepend(const SkString& str) { this->insert(0, str.c_str(), str.size()); }
prepend(std::string_view str)222 void prepend(std::string_view str) { this->insert(0, str.data(), str.size()); }
prependUnichar(SkUnichar uni)223 void prependUnichar(SkUnichar uni) { this->insertUnichar(0, uni); }
prependS32(int32_t value)224 void prependS32(int32_t value) { this->insertS32(0, value); }
225 void prependS64(int32_t value, int minDigits = 0) { this->insertS64(0, value, minDigits); }
226 void prependHex(uint32_t value, int minDigits = 0) { this->insertHex(0, value, minDigits); }
prependScalar(SkScalar value)227 void prependScalar(SkScalar value) { this->insertScalar((size_t)-1, value); }
228
229 void printf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
230 void printVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
231 void appendf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
232 void appendVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
233 void prependf(const char format[], ...) SK_PRINTF_LIKE(2, 3);
234 void prependVAList(const char format[], va_list) SK_PRINTF_LIKE(2, 0);
235
236 void remove(size_t offset, size_t length);
237
238 SkString& operator+=(const SkString& s) { this->append(s); return *this; }
239 SkString& operator+=(const char text[]) { this->append(text); return *this; }
240 SkString& operator+=(const char c) { this->append(&c, 1); return *this; }
241
242 /**
243 * Swap contents between this and other. This function is guaranteed
244 * to never fail or throw.
245 */
246 void swap(SkString& other);
247
248 using sk_is_trivially_relocatable = std::true_type;
249
250 private:
251 struct Rec {
252 public:
RecRec253 constexpr Rec(uint32_t len, int32_t refCnt) : fLength(len), fRefCnt(refCnt) {}
254 static sk_sp<Rec> Make(const char text[], size_t len);
dataRec255 char* data() { return fBeginningOfData; }
dataRec256 const char* data() const { return fBeginningOfData; }
257 void ref() const;
258 void unref() const;
259 bool unique() const;
260 #ifdef SK_DEBUG
261 int32_t getRefCnt() const;
262 #endif
263 uint32_t fLength; // logically size_t, but we want it to stay 32 bits
264
265 private:
266 mutable std::atomic<int32_t> fRefCnt;
267 char fBeginningOfData[1] = {'\0'};
268
269 // Ensure the unsized delete is called.
deleteRec270 void operator delete(void* p) { ::operator delete(p); }
271 };
272 sk_sp<Rec> fRec;
273
274 static_assert(::sk_is_trivially_relocatable<decltype(fRec)>::value);
275
276 #ifdef SK_DEBUG
277 SkString& validate();
278 const SkString& validate() const;
279 #else
validate()280 SkString& validate() { return *this; }
validate()281 const SkString& validate() const { return *this; }
282 #endif
283
284 static const Rec gEmptyRec;
285 };
286
287 /// Creates a new string and writes into it using a printf()-style format.
288 SK_API SkString SkStringPrintf(const char* format, ...) SK_PRINTF_LIKE(1, 2);
289 /// This makes it easier to write a caller as a VAR_ARGS function where the format string is
290 /// optional.
SkStringPrintf()291 static inline SkString SkStringPrintf() { return SkString(); }
292
swap(SkString & a,SkString & b)293 static inline void swap(SkString& a, SkString& b) {
294 a.swap(b);
295 }
296
297 #endif
298