STRING Class Reference

#include <strngs.h>

Public Member Functions
	STRING ()
	STRING (const STRING &string)
	STRING (const char *string)
	STRING (const char *data, int length)
	~STRING ()
bool	Serialize (FILE *fp) const
bool	DeSerialize (bool swap, FILE *fp)
bool	Serialize (tesseract::TFile *fp) const
bool	DeSerialize (tesseract::TFile *fp)
bool	contains (const char c) const
int32_t	length () const
int32_t	size () const
uint32_t	unsigned_size () const
const char *	string () const
const char *	c_str () const
char *	strdup () const
char &	operator[] (int32_t index) const
void	split (const char c, GenericVector< STRING > *splited)
void	truncate_at (int32_t index)
bool	operator== (const STRING &string) const
bool	operator!= (const STRING &string) const
bool	operator!= (const char *string) const
STRING &	operator= (const char *string)
STRING &	operator= (const STRING &string)
STRING	operator+ (const STRING &string) const
STRING	operator+ (const char ch) const
STRING &	operator+= (const char *string)
STRING &	operator+= (const STRING &string)
STRING &	operator+= (const char ch)
void	assign (const char *cstr, int len)
void	add_str_int (const char *str, int number)
void	add_str_double (const char *str, double number)
void	ensure (int32_t min_capacity)

Static Public Member Functions
static bool	SkipDeSerialize (tesseract::TFile *fp)

Detailed Description

Definition at line 45 of file strngs.h.

Constructor & Destructor Documentation

STRING() [1/4]

STRING::STRING

(

)

Definition at line 105 of file strngs.cpp.

               {
  // Empty STRINGs contain just the "\0".
  memcpy(AllocData(1, kMinCapacity), "", 1);
}

STRING() [2/4]

STRING::STRING

(

const STRING &

string

)

Definition at line 110 of file strngs.cpp.

                                {
  str.FixHeader();
  const STRING_HEADER* str_header  = str.GetHeader();
  const int str_used  = str_header->used_;
  char *this_cstr = AllocData(str_used, str_used);
  memcpy(this_cstr, str.GetCStr(), str_used);
  assert(InvariantOk());
}

STRING() [3/4]

STRING::STRING

(

const char *

string

)

Definition at line 119 of file strngs.cpp.

                               {
  if (cstr == nullptr) {
    // Empty STRINGs contain just the "\0".
    memcpy(AllocData(1, kMinCapacity), "", 1);
  } else {
    const int len = strlen(cstr) + 1;
    char* this_cstr = AllocData(len, len);
    memcpy(this_cstr, cstr, len);
  }
  assert(InvariantOk());
}

STRING() [4/4]

STRING::STRING	(	const char *	data,
		int	length
	)

Definition at line 131 of file strngs.cpp.

                                           {
  if (data == nullptr) {
    // Empty STRINGs contain just the "\0".
    memcpy(AllocData(1, kMinCapacity), "", 1);
  } else {
    char* this_cstr = AllocData(length + 1, length + 1);
    memcpy(this_cstr, data, length);
    this_cstr[length] = '\0';
  }
}

~STRING()

STRING::~STRING

(

)

Definition at line 142 of file strngs.cpp.

                {
  DiscardData();
}

Member Function Documentation

add_str_double()

void STRING::add_str_double	(	const char *	str,
		double	number
	)

Definition at line 389 of file strngs.cpp.

                                                          {
  if (str != nullptr)
    *this += str;
  // Allow space for the maximum possible length of %8g.
  char num_buffer[kMaxDoubleSize];
  snprintf(num_buffer, kMaxDoubleSize - 1, "%.8g", number);
  num_buffer[kMaxDoubleSize - 1] = '\0';
  *this += num_buffer;
}

add_str_int()

void STRING::add_str_int	(	const char *	str,
		int	number
	)

Definition at line 379 of file strngs.cpp.

                                                    {
  if (str != nullptr)
    *this += str;
  // Allow space for the maximum possible length of int64_t.
  char num_buffer[kMaxIntSize];
  snprintf(num_buffer, kMaxIntSize - 1, "%d", number);
  num_buffer[kMaxIntSize - 1] = '\0';
  *this += num_buffer;
}

assign()

void STRING::assign	(	const char *	cstr,
		int	len
	)

Definition at line 420 of file strngs.cpp.

                                             {
  STRING_HEADER* this_header = GetHeader();
  this_header->used_ = 0;  // don't bother copying data if need to realloc
  char* this_cstr = ensure_cstr(len + 1);  // +1 for '\0'

  this_header = GetHeader();  // for realloc
  memcpy(this_cstr, cstr, len);
  this_cstr[len] = '\0';
  this_header->used_ = len + 1;

  assert(InvariantOk());
}

c_str()

const char * STRING::c_str

(

)

const

Definition at line 207 of file strngs.cpp.

                                {
  return string();
}

contains()

bool STRING::contains

(

const char

c

)

const

Definition at line 187 of file strngs.cpp.

                                        {
  return (c != '\0') && (strchr (GetCStr(), c) != nullptr);
}

DeSerialize() [1/2]

bool STRING::DeSerialize	(	bool	swap,
		FILE *	fp
	)

Definition at line 161 of file strngs.cpp.

                                            {
  uint32_t len;
  if (!tesseract::DeSerialize(fp, &len)) return false;
  if (swap)
    ReverseN(&len, sizeof(len));
  // Arbitrarily limit the number of characters to protect against bad data.
  if (len > UINT16_MAX) return false;
  truncate_at(len);
  return tesseract::DeSerialize(fp, GetCStr(), len);
}

DeSerialize() [2/2]

bool STRING::DeSerialize

(

tesseract::TFile *

fp

)

Definition at line 173 of file strngs.cpp.

                                  {
  uint32_t len;
  if (!fp->DeSerialize(&len)) return false;
  truncate_at(len);
  return fp->DeSerialize(GetCStr(), len);
}

ensure()

void STRING::ensure ( int32_t  min_capacity )

inline

Definition at line 121 of file strngs.h.

{ ensure_cstr(min_capacity); }

length()

int32_t STRING::length

(

)

const

Definition at line 191 of file strngs.cpp.

                             {
  FixHeader();
  return GetHeader()->used_ - 1;
}

operator!=() [1/2]

bool STRING::operator!=

(

const STRING &

string

)

const

Definition at line 315 of file strngs.cpp.

                                               {
  FixHeader();
  str.FixHeader();
  const STRING_HEADER* str_header = str.GetHeader();
  const STRING_HEADER* this_header = GetHeader();
  const int this_used = this_header->used_;
  const int str_used  = str_header->used_;

  return (this_used != str_used)
         || (memcmp(GetCStr(), str.GetCStr(), this_used) != 0);
}

operator!=() [2/2]

bool STRING::operator!=

(

const char *

string

)

const

Definition at line 327 of file strngs.cpp.

                                              {
  FixHeader();
  const STRING_HEADER* this_header = GetHeader();

  if (cstr == nullptr)
    return this_header->used_ > 1;  // either '\0' or nullptr
  else {
    const int32_t length = strlen(cstr) + 1;
    return (this_header->used_ != length)
            || (memcmp(GetCStr(), cstr, length) != 0);
  }
}

operator+() [1/2]

STRING STRING::operator+

(

const STRING &

string

)

const

Definition at line 433 of file strngs.cpp.

                                                {
  STRING result(*this);
  result += str;

  assert(InvariantOk());
  return result;
}

operator+() [2/2]

STRING STRING::operator+

(

const char

ch

)

const

Definition at line 442 of file strngs.cpp.

                                            {
  STRING result;
  FixHeader();
  const STRING_HEADER* this_header = GetHeader();
  const int this_used = this_header->used_;
  char* result_cstr = result.ensure_cstr(this_used + 1);
  STRING_HEADER* result_header = result.GetHeader();
  const int result_used = result_header->used_;

  // copies '\0' but we'll overwrite that
  memcpy(result_cstr, GetCStr(), this_used);
  result_cstr[result_used] = ch;      // overwrite old '\0'
  result_cstr[result_used + 1] = '\0';  // append on '\0'
  ++result_header->used_;

  assert(InvariantOk());
  return result;
}

operator+=() [1/3]

STRING & STRING::operator+=

(

const char *

string

)

Definition at line 462 of file strngs.cpp.

                                           {
  if (!str || !*str)  // empty string has no effect
    return *this;

  FixHeader();
  const int len = strlen(str) + 1;
  const int this_used = GetHeader()->used_;
  char* this_cstr = ensure_cstr(this_used + len);
  STRING_HEADER* this_header = GetHeader();  // after ensure for realloc

  // if we had non-empty string then append overwriting old '\0'
  // otherwise replace
  if (this_used > 0) {
    memcpy(this_cstr + this_used - 1, str, len);
    this_header->used_ += len - 1;
  } else {
    memcpy(this_cstr, str, len);
    this_header->used_ = len;
  }

  assert(InvariantOk());
  return *this;
}

operator+=() [2/3]

STRING & STRING::operator+=

(

const STRING &

string

)

Definition at line 356 of file strngs.cpp.

                                             {
  FixHeader();
  str.FixHeader();
  const STRING_HEADER* str_header = str.GetHeader();
  const char* str_cstr = str.GetCStr();
  const int  str_used  = str_header->used_;
  const int  this_used = GetHeader()->used_;
  char* this_cstr = ensure_cstr(this_used + str_used);

  STRING_HEADER* this_header = GetHeader();  // after ensure for realloc

  if (this_used > 1) {
    memcpy(this_cstr + this_used - 1, str_cstr, str_used);
    this_header->used_ += str_used - 1;  // overwrite '\0'
  } else {
    memcpy(this_cstr, str_cstr, str_used);
    this_header->used_ = str_used;
  }

  assert(InvariantOk());
  return *this;
}

operator+=() [3/3]

STRING & STRING::operator+=

(

const char

ch

)

Definition at line 487 of file strngs.cpp.

                                        {
  if (ch == '\0')
    return *this;

  FixHeader();
  int   this_used = GetHeader()->used_;
  char* this_cstr = ensure_cstr(this_used + 1);
  STRING_HEADER* this_header = GetHeader();

  if (this_used > 0)
    --this_used; // undo old empty null if there was one

  this_cstr[this_used++] = ch;   // append ch to end
  this_cstr[this_used++] = '\0'; // append '\0' after ch
  this_header->used_ = this_used;

  assert(InvariantOk());
  return *this;
}

operator=() [1/2]

STRING & STRING::operator=

(

const char *

string

)

Definition at line 399 of file strngs.cpp.

                                           {
  STRING_HEADER* this_header = GetHeader();
  if (cstr) {
    const int len = strlen(cstr) + 1;

    this_header->used_ = 0;  // don't bother copying data if need to realloc
    char* this_cstr = ensure_cstr(len);
    this_header = GetHeader();  // for realloc
    memcpy(this_cstr, cstr, len);
    this_header->used_ = len;
  } else {
    // Reallocate to same state as default constructor.
    DiscardData();
    // Empty STRINGs contain just the "\0".
    memcpy(AllocData(1, kMinCapacity), "", 1);
  }

  assert(InvariantOk());
  return *this;
}

operator=() [2/2]

STRING & STRING::operator=

(

const STRING &

string

)

Definition at line 340 of file strngs.cpp.

                                           {
  str.FixHeader();
  const STRING_HEADER* str_header = str.GetHeader();
  const int str_used = str_header->used_;

  GetHeader()->used_ = 0;  // clear since ensure doesn't need to copy data
  char* this_cstr = ensure_cstr(str_used);
  STRING_HEADER* this_header = GetHeader();

  memcpy(this_cstr, str.GetCStr(), str_used);
  this_header->used_ = str_used;

  assert(InvariantOk());
  return *this;
}

operator==()

bool STRING::operator==

(

const STRING &

string

)

const

Definition at line 303 of file strngs.cpp.

                                               {
  FixHeader();
  str.FixHeader();
  const STRING_HEADER* str_header = str.GetHeader();
  const STRING_HEADER* this_header = GetHeader();
  const int this_used = this_header->used_;
  const int str_used  = str_header->used_;

  return (this_used == str_used)
          && (memcmp(GetCStr(), str.GetCStr(), this_used) == 0);
}

operator[]()

char & STRING::operator[]

(

int32_t

index

)

const

Definition at line 276 of file strngs.cpp.

                                            {
  // Code is casting away this const and mutating the string,
  // so mark used_ as -1 to flag it unreliable.
  GetHeader()->used_ = -1;
  return ((char *)GetCStr())[index];
}

Serialize() [1/2]

bool STRING::Serialize

(

FILE *

fp

)

const

Definition at line 148 of file strngs.cpp.

                                     {
  uint32_t len = length();
  return tesseract::Serialize(fp, &len) &&
         tesseract::Serialize(fp, GetCStr(), len);
}

Serialize() [2/2]

bool STRING::Serialize

(

tesseract::TFile *

fp

)

const

Definition at line 154 of file strngs.cpp.

                                      {
  uint32_t len = length();
  return fp->Serialize(&len) &&
         fp->Serialize(GetCStr(), len);
}

size()

int32_t STRING::size ( ) const

inline

Definition at line 69 of file strngs.h.

{ return length(); }

SkipDeSerialize()

bool STRING::SkipDeSerialize ( tesseract::TFile *  fp )

static

Definition at line 181 of file strngs.cpp.

                                      {
  uint32_t len;
  if (!fp->DeSerialize(&len)) return false;
  return fp->Skip(len);
}

split()

void STRING::split	(	const char	c,
		GenericVector< STRING > *	splited
	)

Definition at line 284 of file strngs.cpp.

                                                               {
  int start_index = 0;
  const int len = length();
  for (int i = 0; i < len; i++) {
    if ((*this)[i] == c) {
      if (i != start_index) {
        (*this)[i] = '\0';
        splited->push_back(STRING(GetCStr() + start_index, i - start_index));
        (*this)[i] = c;
      }
      start_index = i + 1;
    }
  }

  if (len != start_index) {
    splited->push_back(STRING(GetCStr() + start_index, len - start_index));
  }
}

strdup()

char* STRING::strdup ( ) const

inline

Definition at line 79 of file strngs.h.

                                {
     int32_t len = length() + 1;
     return strncpy(new char[len], GetCStr(), len);
    }

string()

const char * STRING::string

(

)

const

Definition at line 196 of file strngs.cpp.

                                 {
  const STRING_HEADER* header = GetHeader();
  if (header->used_ == 0)
    return nullptr;

  // mark header length unreliable because tesseract might
  // cast away the const and mutate the string directly.
  header->used_ = -1;
  return GetCStr();
}

truncate_at()

void STRING::truncate_at

(

int32_t

index

)

Definition at line 267 of file strngs.cpp.

                                      {
  ASSERT_HOST(index >= 0);
  FixHeader();
  char* this_cstr = ensure_cstr(index + 1);
  this_cstr[index] = '\0';
  GetHeader()->used_ = index + 1;
  assert(InvariantOk());
}

unsigned_size()

uint32_t STRING::unsigned_size ( ) const

inline

Definition at line 71 of file strngs.h.

                                   {
      const int32_t len = length();
      assert(0 <= len);
      return static_cast<uint32_t>(len);
    }

---

The documentation for this class was generated from the following files:

• /usr/src/tesseract-ocr.master/src/ccutil/strngs.h
• /usr/src/tesseract-ocr.master/src/ccutil/strngs.cpp