#include <serialis.h>
|
| 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) |
|
Definition at line 69 of file serialis.h.
◆ TFile()
tesseract::TFile::TFile |
( |
| ) |
|
◆ ~TFile()
tesseract::TFile::~TFile |
( |
| ) |
|
◆ CloseWrite()
bool tesseract::TFile::CloseWrite |
( |
const char * |
filename, |
|
|
FileWriter |
writer |
|
) |
| |
Definition at line 263 of file serialis.cpp.
265 if (writer ==
nullptr) {
268 return (*writer)(*data_, filename);
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.
98 }
else if (size > 0) {
bool DeSerialize(std::string &data)
◆ DeSerialize() [2/4]
bool tesseract::TFile::DeSerialize |
( |
std::vector< char > & |
data | ) |
|
◆ DeSerialize() [3/4]
template<typename T >
bool tesseract::TFile::DeSerialize |
( |
std::vector< T > & |
data | ) |
|
|
inline |
Definition at line 98 of file serialis.h.
102 }
else if (size == 0) {
104 }
else if (size > 50000000) {
107 }
else if constexpr (std::is_same<T, std::string>::value) {
111 for (
auto &item : data) {
116 }
else if constexpr (std::is_class<T>::value) {
120 for (
auto &item : data) {
121 if (!item.DeSerialize(
this)) {
125 }
else if constexpr (std::is_pointer<T>::value) {
129 for (uint32_t i = 0; i < size; i++) {
135 typedef typename std::remove_pointer<T>::type ST;
137 if (!item->DeSerialize(
this)) {
◆ 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.
95 return FReadEndian(data,
sizeof(T), count) == count;
size_t FReadEndian(void *buffer, size_t size, size_t count)
◆ DeSerializeSize()
bool tesseract::TFile::DeSerializeSize |
( |
int32_t * |
data | ) |
|
Definition at line 72 of file serialis.cpp.
77 if (size > data_->size() / 4) {
void ReverseN(void *ptr, int num_bytes)
◆ DeSerializeSkip()
bool tesseract::TFile::DeSerializeSkip |
( |
size_t |
size = 1 | ) |
|
◆ FGets()
char * tesseract::TFile::FGets |
( |
char * |
buffer, |
|
|
int |
buffer_size |
|
) |
| |
Definition at line 195 of file serialis.cpp.
198 while (size + 1 < buffer_size && offset_ < data_->size()) {
199 buffer[size++] = (*data_)[offset_++];
200 if ((*data_)[offset_ - 1] ==
'\n') {
204 if (size < buffer_size) {
207 return size > 0 ? buffer :
nullptr;
◆ FRead()
size_t tesseract::TFile::FRead |
( |
void * |
buffer, |
|
|
size_t |
size, |
|
|
size_t |
count |
|
) |
| |
Definition at line 221 of file serialis.cpp.
224 size_t required_size;
225 if (SIZE_MAX / size <= count) {
227 required_size = data_->size() - offset_;
229 required_size = size * count;
230 if (data_->size() - offset_ < required_size) {
231 required_size = data_->size() - offset_;
234 if (required_size > 0 && buffer !=
nullptr) {
235 memcpy(buffer, &(*data_)[offset_], required_size);
237 offset_ += required_size;
238 return required_size / size;
◆ FReadEndian()
size_t tesseract::TFile::FReadEndian |
( |
void * |
buffer, |
|
|
size_t |
size, |
|
|
size_t |
count |
|
) |
| |
Definition at line 210 of file serialis.cpp.
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) {
size_t FRead(void *buffer, size_t size, size_t count)
◆ FWrite()
size_t tesseract::TFile::FWrite |
( |
const void * |
buffer, |
|
|
size_t |
size, |
|
|
size_t |
count |
|
) |
| |
Definition at line 272 of file serialis.cpp.
276 size_t total = size * count;
277 const char *buf =
static_cast<const char *
>(buffer);
280 for (
size_t i = 0; i < total; ++i) {
281 data_->push_back(buf[i]);
◆ Open() [1/3]
bool tesseract::TFile::Open |
( |
const char * |
data, |
|
|
size_t |
size |
|
) |
| |
Definition at line 155 of file serialis.cpp.
157 if (!data_is_owned_) {
158 data_ =
new std::vector<char>;
159 data_is_owned_ =
true;
164 memcpy(&(*data_)[0], data, size);
◆ Open() [2/3]
bool tesseract::TFile::Open |
( |
const char * |
filename, |
|
|
FileReader |
reader |
|
) |
| |
Definition at line 140 of file serialis.cpp.
141 if (!data_is_owned_) {
142 data_ =
new std::vector<char>;
143 data_is_owned_ =
true;
148 if (reader ==
nullptr) {
151 return (*reader)(filename, data_);
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.
170 auto current_pos = std::ftell(fp);
171 if (current_pos < 0) {
175 if (end_offset < 0) {
176 if (fseek(fp, 0, SEEK_END)) {
179 end_offset = ftell(fp);
180 if (fseek(fp, current_pos, SEEK_SET)) {
184 size_t size = end_offset - current_pos;
187 if (!data_is_owned_) {
188 data_ =
new std::vector<char>;
189 data_is_owned_ =
true;
192 return fread(&(*data_)[0], 1, size, fp) == size;
◆ OpenWrite()
void tesseract::TFile::OpenWrite |
( |
std::vector< char > * |
data | ) |
|
Definition at line 246 of file serialis.cpp.
248 if (data !=
nullptr) {
249 if (data_is_owned_) {
253 data_is_owned_ =
false;
254 }
else if (!data_is_owned_) {
255 data_ =
new std::vector<char>;
256 data_is_owned_ =
true;
◆ Rewind()
void tesseract::TFile::Rewind |
( |
| ) |
|
◆ Serialize() [1/4]
bool tesseract::TFile::Serialize |
( |
const std::string & |
data | ) |
|
Definition at line 107 of file serialis.cpp.
108 uint32_t size = data.size();
bool Serialize(const std::string &data)
◆ Serialize() [2/4]
bool tesseract::TFile::Serialize |
( |
const std::vector< char > & |
data | ) |
|
Definition at line 125 of file serialis.cpp.
126 uint32_t size = data.size();
129 }
else if (size > 0) {
◆ Serialize() [3/4]
template<typename T >
bool tesseract::TFile::Serialize |
( |
const std::vector< T > & |
data | ) |
|
|
inline |
Definition at line 161 of file serialis.h.
163 uint32_t size = data.size();
166 }
else if constexpr (std::is_same<T, std::string>::value) {
168 for (
auto string : data) {
173 }
else if constexpr (std::is_class<T>::value) {
175 for (
auto &item : data) {
176 if (!item.Serialize(
this)) {
180 }
else if constexpr (std::is_pointer<T>::value) {
182 for (
auto &item : data) {
183 uint8_t non_null = (item !=
nullptr);
188 if (!item->Serialize(
this)) {
193 }
else if (size > 0) {
◆ 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.
158 return FWrite(data,
sizeof(T), count) == count;
size_t FWrite(const void *buffer, size_t size, size_t count)
◆ set_swap()
void tesseract::TFile::set_swap |
( |
bool |
value | ) |
|
|
inline |
◆ Skip()
bool tesseract::TFile::Skip |
( |
size_t |
count | ) |
|
The documentation for this class was generated from the following files: