Disk ARchive 2.7.16
Full featured and portable backup and archiving tool
Loading...
Searching...
No Matches
generic_file.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2024 Denis Corbin
4//
5// This program is free software; you can redistribute it and/or
6// modify it under the terms of the GNU General Public License
7// as published by the Free Software Foundation; either version 2
8// of the License, or (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18//
19// to contact the author, see the AUTHOR file
20/*********************************************************************/
21
36
37#ifndef GENERIC_FILE_HPP
38#define GENERIC_FILE_HPP
39
40#include "../my_config.h"
41
42extern "C"
43{
44#if HAVE_UNISTD_H
45#include <unistd.h>
46#endif
47} // end extern "C"
48
50#include "integers.hpp"
51#include "crc.hpp"
52#include "infinint.hpp"
53#include "gf_mode.hpp"
54
55#include <string>
56
57namespace libdar
58{
59
62
64
77 {
78 public :
80 generic_file(gf_mode m) { rw = m; terminated = no_read_ahead = false; enable_crc(false); checksum = nullptr; };
81
83 generic_file(const generic_file &ref) { copy_from(ref); };
84
86 generic_file(generic_file && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
87
89 generic_file & operator = (const generic_file & ref) { destroy(); copy_from(ref); return *this; };
90
92 generic_file & operator = (generic_file && ref) noexcept { move_from(std::move(ref)); return *this; };
93
95
97 ~generic_file() noexcept(false) { destroy(); };
98
100 void terminate();
101
106 bool operator != (generic_file & ref) { return ! (*this == ref); };
107
109 gf_mode get_mode() const { return rw; };
110
115 void read_ahead(const infinint & amount);
116
123 void ignore_read_ahead(bool mode) { no_read_ahead = mode; };
124
126 virtual U_I read(char *a, U_I size) override;
127
129 virtual void write(const char *a, U_I size) override;
130
132
134 void write(const std::string & arg);
135
137 S_I read_back(char &a);
138
140 S_I read_forward(char &a) { if(terminated) throw SRC_BUG; return read(&a, 1); };
141
142
143 enum skippability { skip_backward, skip_forward };
144
146
151 virtual bool skippable(skippability direction, const infinint & amount) = 0;
152
154
158 virtual bool skip(const infinint & pos) = 0;
159
161 virtual bool skip_to_eof() = 0;
162
164 virtual bool skip_relative(S_I x) = 0;
165
167
168 virtual bool truncatable(const infinint & pos) const = 0;
169
171
183 virtual void truncate(const infinint & pos);
184
186 virtual infinint get_position() const = 0;
187
189 virtual void copy_to(generic_file &ref);
190
192
197 virtual void copy_to(generic_file &ref, const infinint & crc_size, crc * & value);
198
200 U_32 copy_to(generic_file &ref, U_32 size); // returns the number of byte effectively copied
201
203 infinint copy_to(generic_file &ref, infinint size); // returns the number of byte effectively copied
204
206
218 const infinint & me_read_ahead,
219 const infinint & you_read_ahead,
220 const infinint & crc_size,
221 crc * & value);
222
236 const infinint & me_read_ahead,
237 const infinint & you_read_ahead,
238 const infinint & crc_size,
239 crc * & value,
240 infinint & err_offset);
241
243
245 void reset_crc(const infinint & width);
246
248 bool crc_status() const { return active_read == &generic_file::read_crc; };
249
251
256
259
262
263
264 protected :
265 void set_mode(gf_mode x) { rw = x; };
266
268
272 virtual void inherited_read_ahead(const infinint & amount) = 0;
273
274
276
285 virtual U_I inherited_read(char *a, U_I size) = 0;
286
288
292 virtual void inherited_write(const char *a, U_I size) = 0;
293
295
300 virtual void inherited_truncate(const infinint & pos) = 0;
301
302
304
308 virtual void inherited_sync_write() = 0;
309
311
316 virtual void inherited_flush_read() = 0;
317
319
322 virtual void inherited_terminate() = 0;
323
324
327 bool is_terminated() const { return terminated; };
328
329 private :
330 gf_mode rw;
331 crc *checksum;
332 bool terminated;
333 bool no_read_ahead;
334 U_I (generic_file::* active_read)(char *a, U_I size);
335 void (generic_file::* active_write)(const char *a, U_I size);
336
337 void enable_crc(bool mode);
338
339 U_I read_crc(char *a, U_I size);
340 void write_crc(const char *a, U_I size);
341 void destroy();
342 void nullifyptr() noexcept { checksum = nullptr; };
343 void copy_from(const generic_file & ref);
344 void move_from(generic_file && ref) noexcept;
345 };
346
348
349} // end of namespace
350
351#endif
pure virtual class defining interface of a CRC object
Definition crc.hpp:47
this is the interface class from which all other data transfer classes inherit
virtual void write(const char *a, U_I size) override
write data to the generic_file inherited from proto_generic_file
infinint copy_to(generic_file &ref, infinint size)
copy the given amount to the object in argument
virtual bool truncatable(const infinint &pos) const =0
whether the implementation is able to truncate to the given position
void terminate()
destructor-like call, except that it is allowed to throw exceptions
virtual void inherited_truncate(const infinint &pos)=0
truncate file at the give offset
virtual void inherited_sync_write()=0
write down any pending data
~generic_file() noexcept(false)
virtual destructor,
virtual bool skip(const infinint &pos)=0
skip at the absolute position
generic_file(const generic_file &ref)
copy constructor
virtual void truncate(const infinint &pos)
truncate file at the given offset
generic_file(gf_mode m)
main constructor
generic_file & operator=(const generic_file &ref)
assignment operator
virtual void copy_to(generic_file &ref)
copy all data from current position to the object in argument
virtual bool skippable(skippability direction, const infinint &amount)=0
whether the implementation is able to skip
virtual void copy_to(generic_file &ref, const infinint &crc_size, crc *&value)
copy all data from the current position to the object in argument and computes a CRC value of the tra...
bool crc_status() const
to known whether CRC calculation is activated or not
virtual void inherited_read_ahead(const infinint &amount)=0
tells the object that several calls to read() will follow to probably obtain at least the given amoun...
S_I read_back(char &a)
skip back one char, read on char and skip back one char
void read_ahead(const infinint &amount)
S_I read_forward(char &a)
read one char
virtual infinint get_position() const =0
get the current read/write position
void flush_read()
be ready to read at current position, reseting all pending data for reading, cached and in compressio...
virtual bool skip_relative(S_I x)=0
skip relatively to the current position
bool operator==(generic_file &ref)
virtual bool skip_to_eof()=0
skip to the end of file
virtual void inherited_write(const char *a, U_I size)=0
implementation of the write() operation
virtual U_I inherited_read(char *a, U_I size)=0
implementation of read() operation
bool diff(generic_file &f, const infinint &me_read_ahead, const infinint &you_read_ahead, const infinint &crc_size, crc *&value, infinint &err_offset)
bool diff(generic_file &f, const infinint &me_read_ahead, const infinint &you_read_ahead, const infinint &crc_size, crc *&value)
compares the contents with the object in argument
generic_file(generic_file &&ref) noexcept
move constructor
void reset_crc(const infinint &width)
reset CRC on read or writen data
void ignore_read_ahead(bool mode)
bool is_terminated() const
gf_mode get_mode() const
retreive the openning mode for this object
virtual void inherited_terminate()=0
destructor-like call, except that it is allowed to throw exceptions
void write(const std::string &arg)
write a string to the generic_file
crc * get_crc()
get CRC of the transfered date since last reset
void sync_write()
write any pending data
virtual U_I read(char *a, U_I size) override
read data from the generic_file inherited from proto_generic_file
U_32 copy_to(generic_file &ref, U_32 size)
small copy (up to 4GB) with CRC calculation
virtual void inherited_flush_read()=0
reset internal engine, flush caches in order to read the data at current position
the arbitrary large positive integer class
ancestor class of generic_file
class crc definition, used to handle Cyclic Redundancy Checks
generic modes to open file
gf_mode
generic_file openning modes
Definition gf_mode.hpp:44
switch module to limitint (32 ou 64 bits integers) or infinint
are defined here basic integer types that tend to be portable
include macro defined by the configure script and some specific additional ones
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
precursor class of generic_file used to avoid cyclic dependencies with storage and infinint