tesseract  5.0.0
tesseract::TFile Class Reference

#include <serialis.h>

Public Member Functions

 TFile ()
 
 ~TFile ()
 
bool Open (const char *filename, FileReader reader)
 
bool Open (const char *data, size_t size)
 
bool Open (FILE *fp, int64_t end_offset)
 
void set_swap (bool value)
 
bool DeSerializeSize (int32_t *data)
 
bool DeSerializeSkip (size_t size=1)
 
bool DeSerialize (std::string &data)
 
bool DeSerialize (std::vector< char > &data)
 
template<typename T >
bool DeSerialize (T *data, size_t count=1)
 
template<typename T >
bool DeSerialize (std::vector< T > &data)
 
bool Serialize (const std::string &data)
 
bool Serialize (const std::vector< char > &data)
 
template<typename T >
bool Serialize (const T *data, size_t count=1)
 
template<typename T >
bool Serialize (const std::vector< T > &data)
 
bool Skip (size_t count)
 
char * FGets (char *buffer, int buffer_size)
 
size_t FReadEndian (void *buffer, size_t size, size_t count)
 
size_t FRead (void *buffer, size_t size, size_t count)
 
void Rewind ()
 
void OpenWrite (std::vector< char > *data)
 
bool CloseWrite (const char *filename, FileWriter writer)
 
size_t FWrite (const void *buffer, size_t size, size_t count)
 

Detailed Description

Definition at line 69 of file serialis.h.

Constructor & Destructor Documentation

◆ TFile()

tesseract::TFile::TFile ( )

Definition at line 63 of file serialis.cpp.

63  {
64 }

◆ ~TFile()

tesseract::TFile::~TFile ( )

Definition at line 66 of file serialis.cpp.

66  {
67  if (data_is_owned_) {
68  delete data_;
69  }
70 }

Member Function Documentation

◆ CloseWrite()

bool tesseract::TFile::CloseWrite ( const char *  filename,
FileWriter  writer 
)

Definition at line 263 of file serialis.cpp.

263  {
264  ASSERT_HOST(is_writing_);
265  if (writer == nullptr) {
266  return SaveDataToFile(*data_, filename);
267  } else {
268  return (*writer)(*data_, filename);
269  }
270 }
#define ASSERT_HOST(x)
Definition: errcode.h:59
bool SaveDataToFile(const GenericVector< char > &data, const char *filename)

◆ DeSerialize() [1/4]

bool tesseract::TFile::DeSerialize ( std::string &  data)

Definition at line 94 of file serialis.cpp.

94  {
95  uint32_t size;
96  if (!DeSerialize(&size)) {
97  return false;
98  } else if (size > 0) {
99  // TODO: optimize.
100  data.resize(size);
101  return DeSerialize(&data[0], size);
102  }
103  data.clear();
104  return true;
105 }
bool DeSerialize(std::string &data)
Definition: serialis.cpp:94

◆ DeSerialize() [2/4]

bool tesseract::TFile::DeSerialize ( std::vector< char > &  data)

Definition at line 112 of file serialis.cpp.

112  {
113  uint32_t size;
114  if (!DeSerialize(&size)) {
115  return false;
116  } else if (size > 0) {
117  // TODO: optimize.
118  data.resize(size);
119  return DeSerialize(&data[0], data.size());
120  }
121  data.clear();
122  return true;
123 }

◆ DeSerialize() [3/4]

template<typename T >
bool tesseract::TFile::DeSerialize ( std::vector< T > &  data)
inline

Definition at line 98 of file serialis.h.

98  {
99  uint32_t size;
100  if (!DeSerialize(&size)) {
101  return false;
102  } else if (size == 0) {
103  data.clear();
104  } else if (size > 50000000) {
105  // Arbitrarily limit the number of elements to protect against bad data.
106  return false;
107  } else if constexpr (std::is_same<T, std::string>::value) {
108  // Deserialize a string.
109  // TODO: optimize.
110  data.resize(size);
111  for (auto &item : data) {
112  if (!DeSerialize(item)) {
113  return false;
114  }
115  }
116  } else if constexpr (std::is_class<T>::value) {
117  // Deserialize a tesseract class.
118  // TODO: optimize.
119  data.resize(size);
120  for (auto &item : data) {
121  if (!item.DeSerialize(this)) {
122  return false;
123  }
124  }
125  } else if constexpr (std::is_pointer<T>::value) {
126  // Deserialize pointers.
127  // TODO: optimize.
128  data.resize(size);
129  for (uint32_t i = 0; i < size; i++) {
130  uint8_t non_null;
131  if (!DeSerialize(&non_null)) {
132  return false;
133  }
134  if (non_null) {
135  typedef typename std::remove_pointer<T>::type ST;
136  auto item = new ST;
137  if (!item->DeSerialize(this)) {
138  delete item;
139  return false;
140  }
141  data[i] = item;
142  }
143  }
144  } else {
145  // Deserialize a non-class.
146  // TODO: optimize.
147  data.resize(size);
148  return DeSerialize(&data[0], size);
149  }
150  return true;
151  }

◆ DeSerialize() [4/4]

template<typename T >
bool tesseract::TFile::DeSerialize ( T *  data,
size_t  count = 1 
)
inline

Definition at line 94 of file serialis.h.

94  {
95  return FReadEndian(data, sizeof(T), count) == count;
96  }
size_t FReadEndian(void *buffer, size_t size, size_t count)
Definition: serialis.cpp:210

◆ DeSerializeSize()

bool tesseract::TFile::DeSerializeSize ( int32_t *  data)

Definition at line 72 of file serialis.cpp.

72  {
73  uint32_t size;
74  if (FReadEndian(&size, sizeof(size), 1) != 1) {
75  return false;
76  }
77  if (size > data_->size() / 4) {
78  // Reverse endianness.
79  swap_ = !swap_;
80  ReverseN(&size, 4);
81  }
82  *pSize = size;
83  return true;
84 }
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:189

◆ DeSerializeSkip()

bool tesseract::TFile::DeSerializeSkip ( size_t  size = 1)

Definition at line 86 of file serialis.cpp.

86  {
87  uint32_t len;
88  if (!DeSerialize(&len)) {
89  return false;
90  }
91  return Skip(len * size);
92 }
bool Skip(size_t count)
Definition: serialis.cpp:135

◆ FGets()

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

Definition at line 195 of file serialis.cpp.

195  {
196  ASSERT_HOST(!is_writing_);
197  int size = 0;
198  while (size + 1 < buffer_size && offset_ < data_->size()) {
199  buffer[size++] = (*data_)[offset_++];
200  if ((*data_)[offset_ - 1] == '\n') {
201  break;
202  }
203  }
204  if (size < buffer_size) {
205  buffer[size] = '\0';
206  }
207  return size > 0 ? buffer : nullptr;
208 }

◆ FRead()

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

Definition at line 221 of file serialis.cpp.

221  {
222  ASSERT_HOST(!is_writing_);
223  ASSERT_HOST(size > 0);
224  size_t required_size;
225  if (SIZE_MAX / size <= count) {
226  // Avoid integer overflow.
227  required_size = data_->size() - offset_;
228  } else {
229  required_size = size * count;
230  if (data_->size() - offset_ < required_size) {
231  required_size = data_->size() - offset_;
232  }
233  }
234  if (required_size > 0 && buffer != nullptr) {
235  memcpy(buffer, &(*data_)[offset_], required_size);
236  }
237  offset_ += required_size;
238  return required_size / size;
239 }

◆ FReadEndian()

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

Definition at line 210 of file serialis.cpp.

210  {
211  auto num_read = FRead(buffer, size, count);
212  if (swap_ && size != 1) {
213  char *char_buffer = static_cast<char *>(buffer);
214  for (size_t i = 0; i < num_read; ++i, char_buffer += size) {
215  ReverseN(char_buffer, size);
216  }
217  }
218  return num_read;
219 }
size_t FRead(void *buffer, size_t size, size_t count)
Definition: serialis.cpp:221

◆ FWrite()

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

Definition at line 272 of file serialis.cpp.

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

◆ Open() [1/3]

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

Definition at line 155 of file serialis.cpp.

155  {
156  offset_ = 0;
157  if (!data_is_owned_) {
158  data_ = new std::vector<char>;
159  data_is_owned_ = true;
160  }
161  is_writing_ = false;
162  swap_ = false;
163  data_->resize(size); // TODO: optimize no init
164  memcpy(&(*data_)[0], data, size);
165  return true;
166 }

◆ Open() [2/3]

bool tesseract::TFile::Open ( const char *  filename,
FileReader  reader 
)

Definition at line 140 of file serialis.cpp.

140  {
141  if (!data_is_owned_) {
142  data_ = new std::vector<char>;
143  data_is_owned_ = true;
144  }
145  offset_ = 0;
146  is_writing_ = false;
147  swap_ = false;
148  if (reader == nullptr) {
149  return LoadDataFromFile(filename, data_);
150  } else {
151  return (*reader)(filename, data_);
152  }
153 }
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)

◆ Open() [3/3]

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

Definition at line 168 of file serialis.cpp.

168  {
169  offset_ = 0;
170  auto current_pos = std::ftell(fp);
171  if (current_pos < 0) {
172  // ftell failed.
173  return false;
174  }
175  if (end_offset < 0) {
176  if (fseek(fp, 0, SEEK_END)) {
177  return false;
178  }
179  end_offset = ftell(fp);
180  if (fseek(fp, current_pos, SEEK_SET)) {
181  return false;
182  }
183  }
184  size_t size = end_offset - current_pos;
185  is_writing_ = false;
186  swap_ = false;
187  if (!data_is_owned_) {
188  data_ = new std::vector<char>;
189  data_is_owned_ = true;
190  }
191  data_->resize(size); // TODO: optimize no init
192  return fread(&(*data_)[0], 1, size, fp) == size;
193 }

◆ OpenWrite()

void tesseract::TFile::OpenWrite ( std::vector< char > *  data)

Definition at line 246 of file serialis.cpp.

246  {
247  offset_ = 0;
248  if (data != nullptr) {
249  if (data_is_owned_) {
250  delete data_;
251  }
252  data_ = data;
253  data_is_owned_ = false;
254  } else if (!data_is_owned_) {
255  data_ = new std::vector<char>;
256  data_is_owned_ = true;
257  }
258  is_writing_ = true;
259  swap_ = false;
260  data_->clear();
261 }

◆ Rewind()

void tesseract::TFile::Rewind ( )

Definition at line 241 of file serialis.cpp.

241  {
242  ASSERT_HOST(!is_writing_);
243  offset_ = 0;
244 }

◆ Serialize() [1/4]

bool tesseract::TFile::Serialize ( const std::string &  data)

Definition at line 107 of file serialis.cpp.

107  {
108  uint32_t size = data.size();
109  return Serialize(&size) && Serialize(data.c_str(), size);
110 }
bool Serialize(const std::string &data)
Definition: serialis.cpp:107

◆ Serialize() [2/4]

bool tesseract::TFile::Serialize ( const std::vector< char > &  data)

Definition at line 125 of file serialis.cpp.

125  {
126  uint32_t size = data.size();
127  if (!Serialize(&size)) {
128  return false;
129  } else if (size > 0) {
130  return Serialize(&data[0], size);
131  }
132  return true;
133 }

◆ Serialize() [3/4]

template<typename T >
bool tesseract::TFile::Serialize ( const std::vector< T > &  data)
inline

Definition at line 161 of file serialis.h.

161  {
162  // Serialize number of elements first.
163  uint32_t size = data.size();
164  if (!Serialize(&size)) {
165  return false;
166  } else if constexpr (std::is_same<T, std::string>::value) {
167  // Serialize strings.
168  for (auto string : data) {
169  if (!Serialize(string)) {
170  return false;
171  }
172  }
173  } else if constexpr (std::is_class<T>::value) {
174  // Serialize a tesseract class.
175  for (auto &item : data) {
176  if (!item.Serialize(this)) {
177  return false;
178  }
179  }
180  } else if constexpr (std::is_pointer<T>::value) {
181  // Serialize pointers.
182  for (auto &item : data) {
183  uint8_t non_null = (item != nullptr);
184  if (!Serialize(&non_null)) {
185  return false;
186  }
187  if (non_null) {
188  if (!item->Serialize(this)) {
189  return false;
190  }
191  }
192  }
193  } else if (size > 0) {
194  // Serialize a non-class.
195  return Serialize(&data[0], size);
196  }
197  return true;
198  }

◆ Serialize() [4/4]

template<typename T >
bool tesseract::TFile::Serialize ( const T *  data,
size_t  count = 1 
)
inline

Definition at line 157 of file serialis.h.

157  {
158  return FWrite(data, sizeof(T), count) == count;
159  }
size_t FWrite(const void *buffer, size_t size, size_t count)
Definition: serialis.cpp:272

◆ set_swap()

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

Definition at line 83 of file serialis.h.

83  {
84  swap_ = value;
85  }

◆ Skip()

bool tesseract::TFile::Skip ( size_t  count)

Definition at line 135 of file serialis.cpp.

135  {
136  offset_ += count;
137  return true;
138 }

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