tesseract v5.3.3.20231005
Public Member Functions | List of all members
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 61 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}
ASSERT_HOST
#define ASSERT_HOST(x)
Definition: errcode.h:54
tesseract::SaveDataToFile
bool SaveDataToFile(const GenericVector< char > &data, const char *filename)
Definition: genericvector.h:254

◆ 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}
tesseract::TFile::DeSerialize
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 90 of file serialis.h.

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

◆ DeSerialize() [4/4]

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

Definition at line 86 of file serialis.h.

86 {
87 return FReadEndian(data, sizeof(T), count) == count;
88 }
count
int * count
Definition: gmock_stress_test.cc:96
tesseract::TFile::FReadEndian
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}
tesseract::ReverseN
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:184

◆ 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}
tesseract::TFile::Skip
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}
tesseract::TFile::FRead
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}
tesseract::LoadDataFromFile
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
Definition: genericvector.h:233

◆ 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}
tesseract::TFile::Serialize
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 153 of file serialis.h.

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

◆ Serialize() [4/4]

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

Definition at line 149 of file serialis.h.

149 {
150 return FWrite(data, sizeof(T), count) == count;
151 }
tesseract::TFile::FWrite
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 75 of file serialis.h.

75 {
76 swap_ = value;
77 }

◆ 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: