51 char* STRING::AllocData(
int used,
int capacity) {
52 data_ =
static_cast<STRING_HEADER *
>(malloc(capacity +
sizeof(STRING_HEADER)));
55 STRING_HEADER* header = GetHeader();
56 header->capacity_ = capacity;
61 void STRING::DiscardData() {
68 char* STRING::ensure_cstr(int32_t min_capacity) {
69 STRING_HEADER* orig_header = GetHeader();
70 if (min_capacity <= orig_header->capacity_)
71 return (
reinterpret_cast<char *
>(this->data_)) +
sizeof(STRING_HEADER);
76 if (min_capacity < 2 * orig_header->capacity_)
77 min_capacity = 2 * orig_header->capacity_;
79 int alloc =
sizeof(STRING_HEADER) + min_capacity;
80 auto* new_header =
static_cast<STRING_HEADER*
>(malloc(alloc));
82 memcpy(&new_header[1], GetCStr(), orig_header->used_);
83 new_header->capacity_ = min_capacity;
84 new_header->used_ = orig_header->used_;
90 assert(InvariantOk());
91 return (
reinterpret_cast<char *
>(data_)) +
sizeof(STRING_HEADER);
96 void STRING::FixHeader()
const {
97 const STRING_HEADER* header = GetHeader();
98 if (header->used_ < 0)
99 header->used_ = strlen(GetCStr()) + 1;
110 const STRING_HEADER* str_header = str.GetHeader();
111 const int str_used = str_header->used_;
112 char *this_cstr = AllocData(str_used, str_used);
113 memcpy(this_cstr, str.GetCStr(), str_used);
114 assert(InvariantOk());
118 if (cstr ==
nullptr) {
122 const int len = strlen(cstr) + 1;
123 char* this_cstr = AllocData(len, len);
124 memcpy(this_cstr, cstr, len);
126 assert(InvariantOk());
130 if (data ==
nullptr) {
135 memcpy(this_cstr, data,
length);
165 if (len > UINT16_MAX)
return false;
182 return fp->
Skip(len);
186 return (c !=
'\0') && (strchr (GetCStr(), c) !=
nullptr);
191 return GetHeader()->used_ - 1;
195 const STRING_HEADER* header = GetHeader();
196 if (!header || header->used_ == 0)
216 #if STRING_IS_PROTECTED
218 return GetCStr()[index];
221 void STRING::insert_range(int32_t index,
const char* str,
int len) {
224 STRING_HEADER* this_header = GetHeader();
225 int used = this_header->used_;
229 char* this_cstr = ensure_cstr(used + len + 1);
232 memmove(this_cstr + index + len,
234 this_header->used_ - index);
235 }
else if (len > 0) {
237 this_cstr[this_header->used_ + len - 1] =
'\0';
242 if (this_header->used_ == 0)
243 ++this_header->used_;
248 memcpy(this_cstr + index, str, len);
249 this_header->used_ += len;
251 assert(InvariantOk());
254 void STRING::erase_range(int32_t index,
int len) {
255 char* this_cstr = GetCStr();
256 STRING_HEADER* this_header = GetHeader();
258 memcpy(this_cstr+index, this_cstr+index+len,
259 this_header->used_ - index - len);
260 this_header->used_ -= len;
261 assert(InvariantOk());
268 char* this_cstr = ensure_cstr(index + 1);
269 this_cstr[index] =
'\0';
270 GetHeader()->used_ = index + 1;
271 assert(InvariantOk());
277 GetHeader()->used_ = -1;
278 return (
const_cast<char *
>(GetCStr()))[index];
285 for (
int i = 0; i < len; i++) {
286 if ((*
this)[i] == c) {
287 if (i != start_index) {
296 if (len != start_index) {
297 splited->
push_back(
STRING(GetCStr() + start_index, len - start_index));
304 const STRING_HEADER* str_header = str.GetHeader();
305 const STRING_HEADER* this_header = GetHeader();
306 const int this_used = this_header->used_;
307 const int str_used = str_header->used_;
309 return (this_used == str_used)
310 && (memcmp(GetCStr(), str.GetCStr(), this_used) == 0);
316 const STRING_HEADER* str_header = str.GetHeader();
317 const STRING_HEADER* this_header = GetHeader();
318 const int this_used = this_header->used_;
319 const int str_used = str_header->used_;
321 return (this_used != str_used)
322 || (memcmp(GetCStr(), str.GetCStr(), this_used) != 0);
327 const STRING_HEADER* this_header = GetHeader();
330 return this_header->used_ > 1;
332 const int32_t
length = strlen(cstr) + 1;
333 return (this_header->used_ !=
length)
334 || (memcmp(GetCStr(), cstr,
length) != 0);
340 const STRING_HEADER* str_header = str.GetHeader();
341 const int str_used = str_header->used_;
343 GetHeader()->used_ = 0;
344 char* this_cstr = ensure_cstr(str_used);
345 STRING_HEADER* this_header = GetHeader();
347 memcpy(this_cstr, str.GetCStr(), str_used);
348 this_header->used_ = str_used;
350 assert(InvariantOk());
357 const STRING_HEADER* str_header = str.GetHeader();
358 const char* str_cstr = str.GetCStr();
359 const int str_used = str_header->used_;
360 const int this_used = GetHeader()->used_;
361 char* this_cstr = ensure_cstr(this_used + str_used);
363 STRING_HEADER* this_header = GetHeader();
366 memcpy(this_cstr + this_used - 1, str_cstr, str_used);
367 this_header->used_ += str_used - 1;
369 memcpy(this_cstr, str_cstr, str_used);
370 this_header->used_ = str_used;
373 assert(InvariantOk());
382 snprintf(num_buffer,
kMaxIntSize - 1,
"%d", number);
390 std::stringstream stream;
392 stream.imbue(std::locale::classic());
396 *
this += stream.str().c_str();
400 STRING_HEADER* this_header = GetHeader();
402 const int len = strlen(cstr) + 1;
404 this_header->used_ = 0;
405 char* this_cstr = ensure_cstr(len);
406 this_header = GetHeader();
407 memcpy(this_cstr, cstr, len);
408 this_header->used_ = len;
416 assert(InvariantOk());
421 STRING_HEADER* this_header = GetHeader();
422 this_header->used_ = 0;
423 char* this_cstr = ensure_cstr(len + 1);
425 this_header = GetHeader();
426 memcpy(this_cstr, cstr, len);
427 this_cstr[len] =
'\0';
428 this_header->used_ = len + 1;
430 assert(InvariantOk());
437 assert(InvariantOk());
445 const STRING_HEADER* this_header = GetHeader();
446 const int this_used = this_header->used_;
447 char* result_cstr = result.ensure_cstr(this_used + 1);
448 STRING_HEADER* result_header = result.GetHeader();
449 const int result_used = result_header->used_;
452 memcpy(result_cstr, GetCStr(), this_used);
453 result_cstr[result_used] = ch;
454 result_cstr[result_used + 1] =
'\0';
455 ++result_header->used_;
457 assert(InvariantOk());
467 const int len = strlen(str) + 1;
468 const int this_used = GetHeader()->used_;
469 char* this_cstr = ensure_cstr(this_used + len);
470 STRING_HEADER* this_header = GetHeader();
475 memcpy(this_cstr + this_used - 1, str, len);
476 this_header->used_ += len - 1;
478 memcpy(this_cstr, str, len);
479 this_header->used_ = len;
482 assert(InvariantOk());
492 int this_used = GetHeader()->used_;
493 char* this_cstr = ensure_cstr(this_used + 1);
494 STRING_HEADER* this_header = GetHeader();
499 this_cstr[this_used++] = ch;
500 this_cstr[this_used++] =
'\0';
501 this_header->used_ = this_used;
503 assert(InvariantOk());
void ReverseN(void *ptr, int num_bytes)
bool DeSerialize(FILE *fp, char *data, size_t n)
bool Serialize(FILE *fp, const char *data, size_t n)
bool Serialize(const char *data, size_t count=1)
bool DeSerialize(char *data, size_t count=1)
bool Serialize(FILE *fp) const
char & operator[](int32_t index) const
void truncate_at(int32_t index)
bool operator==(const STRING &string) const
bool operator!=(const STRING &string) const
const char * c_str() const
STRING & operator=(const char *string)
void add_str_int(const char *str, int number)
void add_str_double(const char *str, double number)
void assign(const char *cstr, int len)
bool contains(char c) const
const char * string() const
void split(char c, GenericVector< STRING > *splited)
bool DeSerialize(bool swap, FILE *fp)
STRING operator+(const STRING &string) const
static bool SkipDeSerialize(tesseract::TFile *fp)
STRING & operator+=(const char *string)