1 2 /* 3 * Copyright 2006 The Android Open Source Project 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10 #ifndef SkString_DEFINED 11 #define SkString_DEFINED 12 13 #include "SkScalar.h" 14 #include "SkTArray.h" 15 16 #include <stdarg.h> 17 18 /* Some helper functions for C strings 19 */ 20 21 static bool SkStrStartsWith(const char string[], const char prefixStr[]) { 22 SkASSERT(string); 23 SkASSERT(prefixStr); 24 return !strncmp(string, prefixStr, strlen(prefixStr)); 25 } 26 static bool SkStrStartsWith(const char string[], const char prefixChar) { 27 SkASSERT(string); 28 return (prefixChar == *string); 29 } 30 31 bool SkStrEndsWith(const char string[], const char suffixStr[]); 32 bool SkStrEndsWith(const char string[], const char suffixChar); 33 34 int SkStrStartsWithOneOf(const char string[], const char prefixes[]); 35 36 static int SkStrFind(const char string[], const char substring[]) { 37 const char *first = strstr(string, substring); 38 if (NULL == first) return -1; 39 return SkToS32(first - &string[0]); 40 } 41 42 static bool SkStrContains(const char string[], const char substring[]) { 43 SkASSERT(string); 44 SkASSERT(substring); 45 return (-1 != SkStrFind(string, substring)); 46 } 47 static bool SkStrContains(const char string[], const char subchar) { 48 SkASSERT(string); 49 char tmp[2]; 50 tmp[0] = subchar; 51 tmp[1] = '\0'; 52 return (-1 != SkStrFind(string, tmp)); 53 } 54 55 static inline char *SkStrDup(const char string[]) { 56 char *ret = (char *) sk_malloc_throw(strlen(string)+1); 57 memcpy(ret,string,strlen(string)+1); 58 return ret; 59 } 60 61 62 63 #define SkStrAppendU32_MaxSize 10 64 char* SkStrAppendU32(char buffer[], uint32_t); 65 #define SkStrAppendU64_MaxSize 20 66 char* SkStrAppendU64(char buffer[], uint64_t, int minDigits); 67 68 #define SkStrAppendS32_MaxSize (SkStrAppendU32_MaxSize + 1) 69 char* SkStrAppendS32(char buffer[], int32_t); 70 #define SkStrAppendS64_MaxSize (SkStrAppendU64_MaxSize + 1) 71 char* SkStrAppendS64(char buffer[], int64_t, int minDigits); 72 73 /** 74 * Floats have at most 8 significant digits, so we limit our %g to that. 75 * However, the total string could be 15 characters: -1.2345678e-005 76 * 77 * In theory we should only expect up to 2 digits for the exponent, but on 78 * some platforms we have seen 3 (as in the example above). 79 */ 80 #define SkStrAppendScalar_MaxSize 15 81 82 /** 83 * Write the scaler in decimal format into buffer, and return a pointer to 84 * the next char after the last one written. Note: a terminating 0 is not 85 * written into buffer, which must be at least SkStrAppendScalar_MaxSize. 86 * Thus if the caller wants to add a 0 at the end, buffer must be at least 87 * SkStrAppendScalar_MaxSize + 1 bytes large. 88 */ 89 #ifdef SK_SCALAR_IS_FLOAT 90 #define SkStrAppendScalar SkStrAppendFloat 91 #else 92 #define SkStrAppendScalar SkStrAppendFixed 93 #endif 94 95 char* SkStrAppendFloat(char buffer[], float); 96 char* SkStrAppendFixed(char buffer[], SkFixed); 97 98 /** \class SkString 99 100 Light weight class for managing strings. Uses reference 101 counting to make string assignments and copies very fast 102 with no extra RAM cost. Assumes UTF8 encoding. 103 */ 104 class SK_API SkString { 105 public: 106 SkString(); 107 explicit SkString(size_t len); 108 explicit SkString(const char text[]); 109 SkString(const char text[], size_t len); 110 SkString(const SkString&); 111 ~SkString(); 112 113 bool isEmpty() const { return 0 == fRec->fLength; } 114 size_t size() const { return (size_t) fRec->fLength; } 115 const char* c_str() const { return fRec->data(); } 116 char operator[](size_t n) const { return this->c_str()[n]; } 117 118 bool equals(const SkString&) const; 119 bool equals(const char text[]) const; 120 bool equals(const char text[], size_t len) const; 121 122 bool startsWith(const char prefixStr[]) const { 123 return SkStrStartsWith(fRec->data(), prefixStr); 124 } 125 bool startsWith(const char prefixChar) const { 126 return SkStrStartsWith(fRec->data(), prefixChar); 127 } 128 bool endsWith(const char suffixStr[]) const { 129 return SkStrEndsWith(fRec->data(), suffixStr); 130 } 131 bool endsWith(const char suffixChar) const { 132 return SkStrEndsWith(fRec->data(), suffixChar); 133 } 134 bool contains(const char substring[]) const { 135 return SkStrContains(fRec->data(), substring); 136 } 137 bool contains(const char subchar) const { 138 return SkStrContains(fRec->data(), subchar); 139 } 140 int find(const char substring[]) const { 141 return SkStrFind(fRec->data(), substring); 142 } 143 144 friend bool operator==(const SkString& a, const SkString& b) { 145 return a.equals(b); 146 } 147 friend bool operator!=(const SkString& a, const SkString& b) { 148 return !a.equals(b); 149 } 150 151 // these methods edit the string 152 153 SkString& operator=(const SkString&); 154 SkString& operator=(const char text[]); 155 156 char* writable_str(); 157 char& operator[](size_t n) { return this->writable_str()[n]; } 158 159 void reset(); 160 void resize(size_t len) { this->set(NULL, len); } 161 void set(const SkString& src) { *this = src; } 162 void set(const char text[]); 163 void set(const char text[], size_t len); 164 void setUTF16(const uint16_t[]); 165 void setUTF16(const uint16_t[], size_t len); 166 167 void insert(size_t offset, const SkString& src) { this->insert(offset, src.c_str(), src.size()); } 168 void insert(size_t offset, const char text[]); 169 void insert(size_t offset, const char text[], size_t len); 170 void insertUnichar(size_t offset, SkUnichar); 171 void insertS32(size_t offset, int32_t value); 172 void insertS64(size_t offset, int64_t value, int minDigits = 0); 173 void insertU32(size_t offset, uint32_t value); 174 void insertU64(size_t offset, uint64_t value, int minDigits = 0); 175 void insertHex(size_t offset, uint32_t value, int minDigits = 0); 176 void insertScalar(size_t offset, SkScalar); 177 178 void append(const SkString& str) { this->insert((size_t)-1, str); } 179 void append(const char text[]) { this->insert((size_t)-1, text); } 180 void append(const char text[], size_t len) { this->insert((size_t)-1, text, len); } 181 void appendUnichar(SkUnichar uni) { this->insertUnichar((size_t)-1, uni); } 182 void appendS32(int32_t value) { this->insertS32((size_t)-1, value); } 183 void appendS64(int64_t value, int minDigits = 0) { this->insertS64((size_t)-1, value, minDigits); } 184 void appendU32(uint32_t value) { this->insertU32((size_t)-1, value); } 185 void appendU64(uint64_t value, int minDigits = 0) { this->insertU64((size_t)-1, value, minDigits); } 186 void appendHex(uint32_t value, int minDigits = 0) { this->insertHex((size_t)-1, value, minDigits); } 187 void appendScalar(SkScalar value) { this->insertScalar((size_t)-1, value); } 188 189 void prepend(const SkString& str) { this->insert(0, str); } 190 void prepend(const char text[]) { this->insert(0, text); } 191 void prepend(const char text[], size_t len) { this->insert(0, text, len); } 192 void prependUnichar(SkUnichar uni) { this->insertUnichar(0, uni); } 193 void prependS32(int32_t value) { this->insertS32(0, value); } 194 void prependS64(int32_t value, int minDigits = 0) { this->insertS64(0, value, minDigits); } 195 void prependHex(uint32_t value, int minDigits = 0) { this->insertHex(0, value, minDigits); } 196 void prependScalar(SkScalar value) { this->insertScalar((size_t)-1, value); } 197 198 void printf(const char format[], ...) SK_PRINTF_LIKE(2, 3); 199 void appendf(const char format[], ...) SK_PRINTF_LIKE(2, 3); 200 void appendVAList(const char format[], va_list); 201 void prependf(const char format[], ...) SK_PRINTF_LIKE(2, 3); 202 203 void remove(size_t offset, size_t length); 204 205 SkString& operator+=(const SkString& s) { this->append(s); return *this; } 206 SkString& operator+=(const char text[]) { this->append(text); return *this; } 207 SkString& operator+=(const char c) { this->append(&c, 1); return *this; } 208 209 /** 210 * Swap contents between this and other. This function is guaranteed 211 * to never fail or throw. 212 */ 213 void swap(SkString& other); 214 215 private: 216 struct Rec { 217 public: 218 uint32_t fLength; // logically size_t, but we want it to stay 32bits 219 int32_t fRefCnt; 220 char fBeginningOfData; 221 222 char* data() { return &fBeginningOfData; } 223 const char* data() const { return &fBeginningOfData; } 224 }; 225 Rec* fRec; 226 227 #ifdef SK_DEBUG 228 const char* fStr; 229 void validate() const; 230 #else 231 void validate() const {} 232 #endif 233 234 static const Rec gEmptyRec; 235 static Rec* AllocRec(const char text[], size_t len); 236 static Rec* RefRec(Rec*); 237 }; 238 239 /// Creates a new string and writes into it using a printf()-style format. 240 SkString SkStringPrintf(const char* format, ...); 241 242 // Specialized to take advantage of SkString's fast swap path. The unspecialized function is 243 // declared in SkTypes.h and called by SkTSort. 244 template <> inline void SkTSwap(SkString& a, SkString& b) { 245 a.swap(b); 246 } 247 248 // Split str on any characters in delimiters into out. (Think, strtok with a sane API.) 249 void SkStrSplit(const char* str, const char* delimiters, SkTArray<SkString>* out); 250 251 #endif 252
