tesseract::TFile Class Reference

#include <serialis.h>

Public Member Functions
	TFile ()
	~TFile ()
bool	Open (const STRING &filename, FileReader reader)
bool	Open (const char *data, int size)
bool	Open (FILE *fp, int64_t end_offset)
void	set_swap (bool value)
bool	DeSerialize (char *data, size_t count=1)
bool	DeSerialize (double *data, size_t count=1)
bool	DeSerialize (float *data, size_t count=1)
bool	DeSerialize (int8_t *data, size_t count=1)
bool	DeSerialize (int16_t *data, size_t count=1)
bool	DeSerialize (int32_t *data, size_t count=1)
bool	DeSerialize (int64_t *data, size_t count=1)
bool	DeSerialize (uint8_t *data, size_t count=1)
bool	DeSerialize (uint16_t *data, size_t count=1)
bool	DeSerialize (uint32_t *data, size_t count=1)
bool	DeSerialize (uint64_t *data, size_t count=1)
bool	Serialize (const char *data, size_t count=1)
bool	Serialize (const double *data, size_t count=1)
bool	Serialize (const float *data, size_t count=1)
bool	Serialize (const int8_t *data, size_t count=1)
bool	Serialize (const int16_t *data, size_t count=1)
bool	Serialize (const int32_t *data, size_t count=1)
bool	Serialize (const int64_t *data, size_t count=1)
bool	Serialize (const uint8_t *data, size_t count=1)
bool	Serialize (const uint16_t *data, size_t count=1)
bool	Serialize (const uint32_t *data, size_t count=1)
bool	Serialize (const uint64_t *data, size_t count=1)
bool	Skip (size_t count)
char *	FGets (char *buffer, int buffer_size)
int	FReadEndian (void *buffer, size_t size, int count)
int	FRead (void *buffer, size_t size, int count)
void	Rewind ()
void	OpenWrite (GenericVector< char > *data)
bool	CloseWrite (const STRING &filename, FileWriter writer)
int	FWrite (const void *buffer, size_t size, int count)

Detailed Description

Definition at line 77 of file serialis.h.

Constructor & Destructor Documentation

TFile()

tesseract::TFile::TFile

(

)

Definition at line 91 of file serialis.cpp.

    : offset_(0),
      data_(nullptr),
      data_is_owned_(false),
      is_writing_(false),
      swap_(false) {}

~TFile()

tesseract::TFile::~TFile

(

)

Definition at line 98 of file serialis.cpp.

              {
  if (data_is_owned_)
    delete data_;
}

Member Function Documentation

CloseWrite()

bool tesseract::TFile::CloseWrite	(	const STRING &	filename,
		FileWriter	writer
	)

Definition at line 310 of file serialis.cpp.

                                                                {
  ASSERT_HOST(is_writing_);
  if (writer == nullptr)
    return SaveDataToFile(*data_, filename);
  else
    return (*writer)(*data_, filename);
}

DeSerialize() [1/11]

bool tesseract::TFile::DeSerialize	(	char *	data,
		size_t	count = 1
	)

Definition at line 103 of file serialis.cpp.

                                                  {
  return FRead(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [2/11]

bool tesseract::TFile::DeSerialize	(	double *	data,
		size_t	count = 1
	)

Definition at line 107 of file serialis.cpp.

                                                    {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [3/11]

bool tesseract::TFile::DeSerialize	(	float *	data,
		size_t	count = 1
	)

Definition at line 111 of file serialis.cpp.

                                                   {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [4/11]

bool tesseract::TFile::DeSerialize	(	int8_t *	data,
		size_t	count = 1
	)

Definition at line 115 of file serialis.cpp.

                                                    {
  return FRead(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [5/11]

bool tesseract::TFile::DeSerialize	(	int16_t *	data,
		size_t	count = 1
	)

Definition at line 119 of file serialis.cpp.

                                                     {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [6/11]

bool tesseract::TFile::DeSerialize	(	int32_t *	data,
		size_t	count = 1
	)

Definition at line 123 of file serialis.cpp.

                                                     {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [7/11]

bool tesseract::TFile::DeSerialize	(	int64_t *	data,
		size_t	count = 1
	)

Definition at line 127 of file serialis.cpp.

                                                     {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [8/11]

bool tesseract::TFile::DeSerialize	(	uint8_t *	data,
		size_t	count = 1
	)

Definition at line 131 of file serialis.cpp.

                                                     {
  return FRead(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [9/11]

bool tesseract::TFile::DeSerialize	(	uint16_t *	data,
		size_t	count = 1
	)

Definition at line 135 of file serialis.cpp.

                                                      {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [10/11]

bool tesseract::TFile::DeSerialize	(	uint32_t *	data,
		size_t	count = 1
	)

Definition at line 139 of file serialis.cpp.

                                                      {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

DeSerialize() [11/11]

bool tesseract::TFile::DeSerialize	(	uint64_t *	data,
		size_t	count = 1
	)

Definition at line 143 of file serialis.cpp.

                                                      {
  return FReadEndian(buffer, sizeof(*buffer), count) == count;
}

FGets()

char * tesseract::TFile::FGets	(	char *	buffer,
		int	buffer_size
	)

Definition at line 248 of file serialis.cpp.

                                                {
  ASSERT_HOST(!is_writing_);
  int size = 0;
  while (size + 1 < buffer_size && offset_ < data_->size()) {
    buffer[size++] = (*data_)[offset_++];
    if ((*data_)[offset_ - 1] == '\n') break;
  }
  if (size < buffer_size) buffer[size] = '\0';
  return size > 0 ? buffer : nullptr;
}

FRead()

int tesseract::TFile::FRead	(	void *	buffer,
		size_t	size,
		int	count
	)

Definition at line 270 of file serialis.cpp.

                                                     {
  ASSERT_HOST(!is_writing_);
  ASSERT_HOST(size > 0);
  ASSERT_HOST(count >= 0);
  size_t required_size;
  if (SIZE_MAX / size <= count) {
    // Avoid integer overflow.
    required_size = data_->size() - offset_;
  } else {
    required_size = size * count;
    if (data_->size() - offset_ < required_size) {
      required_size = data_->size() - offset_;
    }
  }
  if (required_size > 0 && buffer != nullptr)
    memcpy(buffer, &(*data_)[offset_], required_size);
  offset_ += required_size;
  return required_size / size;
}

FReadEndian()

int tesseract::TFile::FReadEndian	(	void *	buffer,
		size_t	size,
		int	count
	)

Definition at line 259 of file serialis.cpp.

                                                           {
  int num_read = FRead(buffer, size, count);
  if (swap_) {
    char* char_buffer = static_cast<char*>(buffer);
    for (int i = 0; i < num_read; ++i, char_buffer += size) {
      ReverseN(char_buffer, size);
    }
  }
  return num_read;
}

FWrite()

int tesseract::TFile::FWrite	(	const void *	buffer,
		size_t	size,
		int	count
	)

Definition at line 318 of file serialis.cpp.

                                                            {
  ASSERT_HOST(is_writing_);
  ASSERT_HOST(size > 0);
  ASSERT_HOST(count >= 0);
  ASSERT_HOST(SIZE_MAX / size > count);
  size_t total = size * count;
  const char* buf = static_cast<const char*>(buffer);
  // This isn't very efficient, but memory is so fast compared to disk
  // that it is relatively unimportant, and very simple.
  for (size_t i = 0; i < total; ++i)
    data_->push_back(buf[i]);
  return count;
}

Open() [1/3]

bool tesseract::TFile::Open	(	const STRING &	filename,
		FileReader	reader
	)

Definition at line 196 of file serialis.cpp.

                                                          {
  if (!data_is_owned_) {
    data_ = new GenericVector<char>;
    data_is_owned_ = true;
  }
  offset_ = 0;
  is_writing_ = false;
  swap_ = false;
  if (reader == nullptr)
    return LoadDataFromFile(filename, data_);
  else
    return (*reader)(filename, data_);
}

Open() [2/3]

bool tesseract::TFile::Open	(	const char *	data,
		int	size
	)

Definition at line 210 of file serialis.cpp.

                                           {
  offset_ = 0;
  if (!data_is_owned_) {
    data_ = new GenericVector<char>;
    data_is_owned_ = true;
  }
  is_writing_ = false;
  swap_ = false;
  data_->resize_no_init(size);
  memcpy(&(*data_)[0], data, size);
  return true;
}

Open() [3/3]

bool tesseract::TFile::Open	(	FILE *	fp,
		int64_t	end_offset
	)

Definition at line 223 of file serialis.cpp.

                                             {
  offset_ = 0;
  long current_pos = ftell(fp);
  if (current_pos < 0) {
    // ftell failed.
    return false;
  }
  if (end_offset < 0) {
    if (fseek(fp, 0, SEEK_END))
      return false;
    end_offset = ftell(fp);
    if (fseek(fp, current_pos, SEEK_SET))
      return false;
  }
  int size = end_offset - current_pos;
  is_writing_ = false;
  swap_ = false;
  if (!data_is_owned_) {
    data_ = new GenericVector<char>;
    data_is_owned_ = true;
  }
  data_->resize_no_init(size);
  return static_cast<int>(fread(&(*data_)[0], 1, size, fp)) == size;
}

OpenWrite()

void tesseract::TFile::OpenWrite

(

GenericVector< char > *

data

)

Definition at line 295 of file serialis.cpp.

                                               {
  offset_ = 0;
  if (data != nullptr) {
    if (data_is_owned_) delete data_;
    data_ = data;
    data_is_owned_ = false;
  } else if (!data_is_owned_) {
    data_ = new GenericVector<char>;
    data_is_owned_ = true;
  }
  is_writing_ = true;
  swap_ = false;
  data_->truncate(0);
}

Rewind()

void tesseract::TFile::Rewind

(

)

Definition at line 290 of file serialis.cpp.

                   {
  ASSERT_HOST(!is_writing_);
  offset_ = 0;
}

Serialize() [1/11]

bool tesseract::TFile::Serialize	(	const char *	data,
		size_t	count = 1
	)

Definition at line 147 of file serialis.cpp.

                                                      {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [2/11]

bool tesseract::TFile::Serialize	(	const double *	data,
		size_t	count = 1
	)

Definition at line 151 of file serialis.cpp.

                                                        {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [3/11]

bool tesseract::TFile::Serialize	(	const float *	data,
		size_t	count = 1
	)

Definition at line 155 of file serialis.cpp.

                                                       {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [4/11]

bool tesseract::TFile::Serialize	(	const int8_t *	data,
		size_t	count = 1
	)

Definition at line 159 of file serialis.cpp.

                                                        {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [5/11]

bool tesseract::TFile::Serialize	(	const int16_t *	data,
		size_t	count = 1
	)

Definition at line 163 of file serialis.cpp.

                                                         {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [6/11]

bool tesseract::TFile::Serialize	(	const int32_t *	data,
		size_t	count = 1
	)

Definition at line 167 of file serialis.cpp.

                                                         {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [7/11]

bool tesseract::TFile::Serialize	(	const int64_t *	data,
		size_t	count = 1
	)

Definition at line 171 of file serialis.cpp.

                                                         {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [8/11]

bool tesseract::TFile::Serialize	(	const uint8_t *	data,
		size_t	count = 1
	)

Definition at line 175 of file serialis.cpp.

                                                         {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [9/11]

bool tesseract::TFile::Serialize	(	const uint16_t *	data,
		size_t	count = 1
	)

Definition at line 179 of file serialis.cpp.

                                                          {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [10/11]

bool tesseract::TFile::Serialize	(	const uint32_t *	data,
		size_t	count = 1
	)

Definition at line 183 of file serialis.cpp.

                                                          {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

Serialize() [11/11]

bool tesseract::TFile::Serialize	(	const uint64_t *	data,
		size_t	count = 1
	)

Definition at line 187 of file serialis.cpp.

                                                          {
  return FWrite(buffer, sizeof(*buffer), count) == count;
}

set_swap()

void tesseract::TFile::set_swap ( bool  value )

inline

Definition at line 91 of file serialis.h.

{ swap_ = value; }

Skip()

bool tesseract::TFile::Skip

(

size_t

count

)

Definition at line 191 of file serialis.cpp.

                             {
  offset_ += count;
  return true;
}

---

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

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