tesseract 4.1.1
Loading...
Searching...
No Matches
serialis.cpp
Go to the documentation of this file.
1/**********************************************************************
2 * File: serialis.cpp (Formerly serialmac.h)
3 * Description: Inline routines and macros for serialisation functions
4 * Author: Phil Cheatle
5 * Created: Tue Oct 08 08:33:12 BST 1991
6 *
7 * (C) Copyright 1990, Hewlett-Packard Ltd.
8 ** Licensed under the Apache License, Version 2.0 (the "License");
9 ** you may not use this file except in compliance with the License.
10 ** You may obtain a copy of the License at
11 ** http://www.apache.org/licenses/LICENSE-2.0
12 ** Unless required by applicable law or agreed to in writing, software
13 ** distributed under the License is distributed on an "AS IS" BASIS,
14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 ** See the License for the specific language governing permissions and
16 ** limitations under the License.
17 *
18 **********************************************************************/
19
20#include "serialis.h"
21#include <cstdio>
22#include "errcode.h"
23#include "genericvector.h"
24#include "strngs.h" // for STRING
25
26namespace tesseract {
27
28bool DeSerialize(FILE* fp, char* data, size_t n) {
29 return fread(data, sizeof(*data), n, fp) == n;
30}
31
32bool DeSerialize(FILE* fp, float* data, size_t n) {
33 return fread(data, sizeof(*data), n, fp) == n;
34}
35
36bool DeSerialize(FILE* fp, int8_t* data, size_t n) {
37 return fread(data, sizeof(*data), n, fp) == n;
38}
39
40bool DeSerialize(FILE* fp, int16_t* data, size_t n) {
41 return fread(data, sizeof(*data), n, fp) == n;
42}
43
44bool DeSerialize(FILE* fp, int32_t* data, size_t n) {
45 return fread(data, sizeof(*data), n, fp) == n;
46}
47
48bool DeSerialize(FILE* fp, uint8_t* data, size_t n) {
49 return fread(data, sizeof(*data), n, fp) == n;
50}
51
52bool DeSerialize(FILE* fp, uint16_t* data, size_t n) {
53 return fread(data, sizeof(*data), n, fp) == n;
54}
55
56bool DeSerialize(FILE* fp, uint32_t* data, size_t n) {
57 return fread(data, sizeof(*data), n, fp) == n;
58}
59
60bool Serialize(FILE* fp, const char* data, size_t n) {
61 return fwrite(data, sizeof(*data), n, fp) == n;
62}
63
64bool Serialize(FILE* fp, const float* data, size_t n) {
65 return fwrite(data, sizeof(*data), n, fp) == n;
66}
67
68bool Serialize(FILE* fp, const int8_t* data, size_t n) {
69 return fwrite(data, sizeof(*data), n, fp) == n;
70}
71
72bool Serialize(FILE* fp, const int16_t* data, size_t n) {
73 return fwrite(data, sizeof(*data), n, fp) == n;
74}
75
76bool Serialize(FILE* fp, const int32_t* data, size_t n) {
77 return fwrite(data, sizeof(*data), n, fp) == n;
78}
79
80bool Serialize(FILE* fp, const uint8_t* data, size_t n) {
81 return fwrite(data, sizeof(*data), n, fp) == n;
82}
83
84bool Serialize(FILE* fp, const uint16_t* data, size_t n) {
85 return fwrite(data, sizeof(*data), n, fp) == n;
86}
87
88bool Serialize(FILE* fp, const uint32_t* data, size_t n) {
89 return fwrite(data, sizeof(*data), n, fp) == n;
90}
91
93 : offset_(0),
94 data_(nullptr),
95 data_is_owned_(false),
96 is_writing_(false),
97 swap_(false) {}
98
100 if (data_is_owned_)
101 delete data_;
102}
103
104bool TFile::DeSerialize(char* buffer, size_t count) {
105 return FRead(buffer, sizeof(*buffer), count) == count;
106}
107
108bool TFile::DeSerialize(double* buffer, size_t count) {
109 return FReadEndian(buffer, sizeof(*buffer), count) == count;
110}
111
112bool TFile::DeSerialize(float* buffer, size_t count) {
113 return FReadEndian(buffer, sizeof(*buffer), count) == count;
114}
115
116bool TFile::DeSerialize(int8_t* buffer, size_t count) {
117 return FRead(buffer, sizeof(*buffer), count) == count;
118}
119
120bool TFile::DeSerialize(int16_t* buffer, size_t count) {
121 return FReadEndian(buffer, sizeof(*buffer), count) == count;
122}
123
124bool TFile::DeSerialize(int32_t* buffer, size_t count) {
125 return FReadEndian(buffer, sizeof(*buffer), count) == count;
126}
127
128bool TFile::DeSerialize(int64_t* buffer, size_t count) {
129 return FReadEndian(buffer, sizeof(*buffer), count) == count;
130}
131
132bool TFile::DeSerialize(uint8_t* buffer, size_t count) {
133 return FRead(buffer, sizeof(*buffer), count) == count;
134}
135
136bool TFile::DeSerialize(uint16_t* buffer, size_t count) {
137 return FReadEndian(buffer, sizeof(*buffer), count) == count;
138}
139
140bool TFile::DeSerialize(uint32_t* buffer, size_t count) {
141 return FReadEndian(buffer, sizeof(*buffer), count) == count;
142}
143
144bool TFile::DeSerialize(uint64_t* buffer, size_t count) {
145 return FReadEndian(buffer, sizeof(*buffer), count) == count;
146}
147
148bool TFile::Serialize(const char* buffer, size_t count) {
149 return FWrite(buffer, sizeof(*buffer), count) == count;
150}
151
152bool TFile::Serialize(const double* buffer, size_t count) {
153 return FWrite(buffer, sizeof(*buffer), count) == count;
154}
155
156bool TFile::Serialize(const float* buffer, size_t count) {
157 return FWrite(buffer, sizeof(*buffer), count) == count;
158}
159
160bool TFile::Serialize(const int8_t* buffer, size_t count) {
161 return FWrite(buffer, sizeof(*buffer), count) == count;
162}
163
164bool TFile::Serialize(const int16_t* buffer, size_t count) {
165 return FWrite(buffer, sizeof(*buffer), count) == count;
166}
167
168bool TFile::Serialize(const int32_t* buffer, size_t count) {
169 return FWrite(buffer, sizeof(*buffer), count) == count;
170}
171
172bool TFile::Serialize(const int64_t* buffer, size_t count) {
173 return FWrite(buffer, sizeof(*buffer), count) == count;
174}
175
176bool TFile::Serialize(const uint8_t* buffer, size_t count) {
177 return FWrite(buffer, sizeof(*buffer), count) == count;
178}
179
180bool TFile::Serialize(const uint16_t* buffer, size_t count) {
181 return FWrite(buffer, sizeof(*buffer), count) == count;
182}
183
184bool TFile::Serialize(const uint32_t* buffer, size_t count) {
185 return FWrite(buffer, sizeof(*buffer), count) == count;
186}
187
188bool TFile::Serialize(const uint64_t* buffer, size_t count) {
189 return FWrite(buffer, sizeof(*buffer), count) == count;
190}
191
192bool TFile::Skip(size_t count) {
193 offset_ += count;
194 return true;
195}
196
197bool TFile::Open(const STRING& filename, FileReader reader) {
198 if (!data_is_owned_) {
199 data_ = new GenericVector<char>;
200 data_is_owned_ = true;
201 }
202 offset_ = 0;
203 is_writing_ = false;
204 swap_ = false;
205 if (reader == nullptr)
206 return LoadDataFromFile(filename.c_str(), data_);
207 else
208 return (*reader)(filename, data_);
209}
210
211bool TFile::Open(const char* data, int size) {
212 offset_ = 0;
213 if (!data_is_owned_) {
214 data_ = new GenericVector<char>;
215 data_is_owned_ = true;
216 }
217 is_writing_ = false;
218 swap_ = false;
219 data_->resize_no_init(size);
220 memcpy(&(*data_)[0], data, size);
221 return true;
222}
223
224bool TFile::Open(FILE* fp, int64_t end_offset) {
225 offset_ = 0;
226 auto current_pos = std::ftell(fp);
227 if (current_pos < 0) {
228 // ftell failed.
229 return false;
230 }
231 if (end_offset < 0) {
232 if (fseek(fp, 0, SEEK_END))
233 return false;
234 end_offset = ftell(fp);
235 if (fseek(fp, current_pos, SEEK_SET))
236 return false;
237 }
238 int size = end_offset - current_pos;
239 is_writing_ = false;
240 swap_ = false;
241 if (!data_is_owned_) {
242 data_ = new GenericVector<char>;
243 data_is_owned_ = true;
244 }
245 data_->resize_no_init(size);
246 return static_cast<int>(fread(&(*data_)[0], 1, size, fp)) == size;
247}
248
249char* TFile::FGets(char* buffer, int buffer_size) {
250 ASSERT_HOST(!is_writing_);
251 int size = 0;
252 while (size + 1 < buffer_size && offset_ < data_->size()) {
253 buffer[size++] = (*data_)[offset_++];
254 if ((*data_)[offset_ - 1] == '\n') break;
255 }
256 if (size < buffer_size) buffer[size] = '\0';
257 return size > 0 ? buffer : nullptr;
258}
259
260int TFile::FReadEndian(void* buffer, size_t size, int count) {
261 int num_read = FRead(buffer, size, count);
262 if (swap_) {
263 char* char_buffer = static_cast<char*>(buffer);
264 for (int i = 0; i < num_read; ++i, char_buffer += size) {
265 ReverseN(char_buffer, size);
266 }
267 }
268 return num_read;
269}
270
271int TFile::FRead(void* buffer, size_t size, int count) {
272 ASSERT_HOST(!is_writing_);
273 ASSERT_HOST(size > 0);
274 ASSERT_HOST(count >= 0);
275 size_t required_size;
276 if (SIZE_MAX / size <= count) {
277 // Avoid integer overflow.
278 required_size = data_->size() - offset_;
279 } else {
280 required_size = size * count;
281 if (data_->size() - offset_ < required_size) {
282 required_size = data_->size() - offset_;
283 }
284 }
285 if (required_size > 0 && buffer != nullptr)
286 memcpy(buffer, &(*data_)[offset_], required_size);
287 offset_ += required_size;
288 return required_size / size;
289}
290
292 ASSERT_HOST(!is_writing_);
293 offset_ = 0;
294}
295
297 offset_ = 0;
298 if (data != nullptr) {
299 if (data_is_owned_) delete data_;
300 data_ = data;
301 data_is_owned_ = false;
302 } else if (!data_is_owned_) {
303 data_ = new GenericVector<char>;
304 data_is_owned_ = true;
305 }
306 is_writing_ = true;
307 swap_ = false;
308 data_->truncate(0);
309}
310
311bool TFile::CloseWrite(const STRING& filename, FileWriter writer) {
312 ASSERT_HOST(is_writing_);
313 if (writer == nullptr)
314 return SaveDataToFile(*data_, filename.c_str());
315 else
316 return (*writer)(*data_, filename);
317}
318
319int TFile::FWrite(const void* buffer, size_t size, int count) {
320 ASSERT_HOST(is_writing_);
321 ASSERT_HOST(size > 0);
322 ASSERT_HOST(count >= 0);
323 ASSERT_HOST(SIZE_MAX / size > count);
324 size_t total = size * count;
325 const char* buf = static_cast<const char*>(buffer);
326 // This isn't very efficient, but memory is so fast compared to disk
327 // that it is relatively unimportant, and very simple.
328 for (size_t i = 0; i < total; ++i)
329 data_->push_back(buf[i]);
330 return count;
331}
332
333} // namespace tesseract.
#define ASSERT_HOST(x)
Definition: errcode.h:88
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:185
int count(LIST var_list)
Definition: oldlist.cpp:95
bool(*)(const STRING &, GenericVector< char > *) FileReader
Definition: serialis.h:49
bool DeSerialize(FILE *fp, char *data, size_t n)
Definition: serialis.cpp:28
bool(*)(const GenericVector< char > &, const STRING &) FileWriter
Definition: serialis.h:52
bool SaveDataToFile(const GenericVector< char > &data, const STRING &filename)
bool Serialize(FILE *fp, const char *data, size_t n)
Definition: serialis.cpp:60
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
void resize_no_init(int size)
Definition: genericvector.h:66
int push_back(T object)
int size() const
Definition: genericvector.h:72
void truncate(int size)
void OpenWrite(GenericVector< char > *data)
Definition: serialis.cpp:296
int FWrite(const void *buffer, size_t size, int count)
Definition: serialis.cpp:319
int FReadEndian(void *buffer, size_t size, int count)
Definition: serialis.cpp:260
int FRead(void *buffer, size_t size, int count)
Definition: serialis.cpp:271
char * FGets(char *buffer, int buffer_size)
Definition: serialis.cpp:249
bool Open(const STRING &filename, FileReader reader)
Definition: serialis.cpp:197
bool Serialize(const char *data, size_t count=1)
Definition: serialis.cpp:148
bool DeSerialize(char *data, size_t count=1)
Definition: serialis.cpp:104
bool Skip(size_t count)
Definition: serialis.cpp:192
bool CloseWrite(const STRING &filename, FileWriter writer)
Definition: serialis.cpp:311
Definition: strngs.h:45
const char * c_str() const
Definition: strngs.cpp:205