tesseract  4.1.1
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 
26 namespace tesseract {
27 
28 bool DeSerialize(FILE* fp, char* data, size_t n) {
29  return fread(data, sizeof(*data), n, fp) == n;
30 }
31 
32 bool DeSerialize(FILE* fp, float* data, size_t n) {
33  return fread(data, sizeof(*data), n, fp) == n;
34 }
35 
36 bool DeSerialize(FILE* fp, int8_t* data, size_t n) {
37  return fread(data, sizeof(*data), n, fp) == n;
38 }
39 
40 bool DeSerialize(FILE* fp, int16_t* data, size_t n) {
41  return fread(data, sizeof(*data), n, fp) == n;
42 }
43 
44 bool DeSerialize(FILE* fp, int32_t* data, size_t n) {
45  return fread(data, sizeof(*data), n, fp) == n;
46 }
47 
48 bool DeSerialize(FILE* fp, uint8_t* data, size_t n) {
49  return fread(data, sizeof(*data), n, fp) == n;
50 }
51 
52 bool DeSerialize(FILE* fp, uint16_t* data, size_t n) {
53  return fread(data, sizeof(*data), n, fp) == n;
54 }
55 
56 bool DeSerialize(FILE* fp, uint32_t* data, size_t n) {
57  return fread(data, sizeof(*data), n, fp) == n;
58 }
59 
60 bool Serialize(FILE* fp, const char* data, size_t n) {
61  return fwrite(data, sizeof(*data), n, fp) == n;
62 }
63 
64 bool Serialize(FILE* fp, const float* data, size_t n) {
65  return fwrite(data, sizeof(*data), n, fp) == n;
66 }
67 
68 bool Serialize(FILE* fp, const int8_t* data, size_t n) {
69  return fwrite(data, sizeof(*data), n, fp) == n;
70 }
71 
72 bool Serialize(FILE* fp, const int16_t* data, size_t n) {
73  return fwrite(data, sizeof(*data), n, fp) == n;
74 }
75 
76 bool Serialize(FILE* fp, const int32_t* data, size_t n) {
77  return fwrite(data, sizeof(*data), n, fp) == n;
78 }
79 
80 bool Serialize(FILE* fp, const uint8_t* data, size_t n) {
81  return fwrite(data, sizeof(*data), n, fp) == n;
82 }
83 
84 bool Serialize(FILE* fp, const uint16_t* data, size_t n) {
85  return fwrite(data, sizeof(*data), n, fp) == n;
86 }
87 
88 bool 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 
104 bool TFile::DeSerialize(char* buffer, size_t count) {
105  return FRead(buffer, sizeof(*buffer), count) == count;
106 }
107 
108 bool TFile::DeSerialize(double* buffer, size_t count) {
109  return FReadEndian(buffer, sizeof(*buffer), count) == count;
110 }
111 
112 bool TFile::DeSerialize(float* buffer, size_t count) {
113  return FReadEndian(buffer, sizeof(*buffer), count) == count;
114 }
115 
116 bool TFile::DeSerialize(int8_t* buffer, size_t count) {
117  return FRead(buffer, sizeof(*buffer), count) == count;
118 }
119 
120 bool TFile::DeSerialize(int16_t* buffer, size_t count) {
121  return FReadEndian(buffer, sizeof(*buffer), count) == count;
122 }
123 
124 bool TFile::DeSerialize(int32_t* buffer, size_t count) {
125  return FReadEndian(buffer, sizeof(*buffer), count) == count;
126 }
127 
128 bool TFile::DeSerialize(int64_t* buffer, size_t count) {
129  return FReadEndian(buffer, sizeof(*buffer), count) == count;
130 }
131 
132 bool TFile::DeSerialize(uint8_t* buffer, size_t count) {
133  return FRead(buffer, sizeof(*buffer), count) == count;
134 }
135 
136 bool TFile::DeSerialize(uint16_t* buffer, size_t count) {
137  return FReadEndian(buffer, sizeof(*buffer), count) == count;
138 }
139 
140 bool TFile::DeSerialize(uint32_t* buffer, size_t count) {
141  return FReadEndian(buffer, sizeof(*buffer), count) == count;
142 }
143 
144 bool TFile::DeSerialize(uint64_t* buffer, size_t count) {
145  return FReadEndian(buffer, sizeof(*buffer), count) == count;
146 }
147 
148 bool TFile::Serialize(const char* buffer, size_t count) {
149  return FWrite(buffer, sizeof(*buffer), count) == count;
150 }
151 
152 bool TFile::Serialize(const double* buffer, size_t count) {
153  return FWrite(buffer, sizeof(*buffer), count) == count;
154 }
155 
156 bool TFile::Serialize(const float* buffer, size_t count) {
157  return FWrite(buffer, sizeof(*buffer), count) == count;
158 }
159 
160 bool TFile::Serialize(const int8_t* buffer, size_t count) {
161  return FWrite(buffer, sizeof(*buffer), count) == count;
162 }
163 
164 bool TFile::Serialize(const int16_t* buffer, size_t count) {
165  return FWrite(buffer, sizeof(*buffer), count) == count;
166 }
167 
168 bool TFile::Serialize(const int32_t* buffer, size_t count) {
169  return FWrite(buffer, sizeof(*buffer), count) == count;
170 }
171 
172 bool TFile::Serialize(const int64_t* buffer, size_t count) {
173  return FWrite(buffer, sizeof(*buffer), count) == count;
174 }
175 
176 bool TFile::Serialize(const uint8_t* buffer, size_t count) {
177  return FWrite(buffer, sizeof(*buffer), count) == count;
178 }
179 
180 bool TFile::Serialize(const uint16_t* buffer, size_t count) {
181  return FWrite(buffer, sizeof(*buffer), count) == count;
182 }
183 
184 bool TFile::Serialize(const uint32_t* buffer, size_t count) {
185  return FWrite(buffer, sizeof(*buffer), count) == count;
186 }
187 
188 bool TFile::Serialize(const uint64_t* buffer, size_t count) {
189  return FWrite(buffer, sizeof(*buffer), count) == count;
190 }
191 
192 bool TFile::Skip(size_t count) {
193  offset_ += count;
194  return true;
195 }
196 
197 bool 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 
211 bool 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 
224 bool 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 
249 char* 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 
260 int 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 
271 int 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 
311 bool 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 
319 int 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.
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
int FReadEndian(void *buffer, size_t size, int count)
Definition: serialis.cpp:260
bool(*)(const GenericVector< char > &, const STRING &) FileWriter
Definition: serialis.h:52
void OpenWrite(GenericVector< char > *data)
Definition: serialis.cpp:296
void resize_no_init(int size)
Definition: genericvector.h:66
bool Serialize(FILE *fp, const char *data, size_t n)
Definition: serialis.cpp:60
bool Open(const STRING &filename, FileReader reader)
Definition: serialis.cpp:197
const char * c_str() const
Definition: strngs.cpp:205
bool SaveDataToFile(const GenericVector< char > &data, const STRING &filename)
bool CloseWrite(const STRING &filename, FileWriter writer)
Definition: serialis.cpp:311
bool Skip(size_t count)
Definition: serialis.cpp:192
void truncate(int size)
bool(*)(const STRING &, GenericVector< char > *) FileReader
Definition: serialis.h:49
bool DeSerialize(char *data, size_t count=1)
Definition: serialis.cpp:104
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:185
int count(LIST var_list)
Definition: oldlist.cpp:95
bool DeSerialize(FILE *fp, char *data, size_t n)
Definition: serialis.cpp:28
bool Serialize(const char *data, size_t count=1)
Definition: serialis.cpp:148
char * FGets(char *buffer, int buffer_size)
Definition: serialis.cpp:249
Definition: strngs.h:45
int push_back(T object)
int size() const
Definition: genericvector.h:72
int FRead(void *buffer, size_t size, int count)
Definition: serialis.cpp:271
#define ASSERT_HOST(x)
Definition: errcode.h:88
int FWrite(const void *buffer, size_t size, int count)
Definition: serialis.cpp:319