Disk ARchive 2.7.14
Full featured and portable backup and archiving tool
Loading...
Searching...
No Matches
trivial_sar.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
25
26#ifndef TRIVIAL_SAR_HPP
27#define TRIVIAL_SAR_HPP
28
29#include "../my_config.h"
30
31#include <string>
32#include "infinint.hpp"
33#include "generic_file.hpp"
34#include "integers.hpp"
35#include "entrepot.hpp"
36#include "contextual.hpp"
37#include "mem_ui.hpp"
38
39namespace libdar
40{
41 // contextual is defined in generic_file module
42
45
52
53 class trivial_sar : public generic_file, public contextual, protected mem_ui
54 {
55 public:
57 trivial_sar(const std::shared_ptr<user_interaction> & dialog,
59 const std::string & base_name,
60 const std::string & extension,
61 const entrepot & where,
62 const label & internal_nale,
63 const label & data_name,
64 const std::string & execute,
65 bool allow_over,
66 bool warn_over,
67 bool force_permission,
68 U_I permission,
69 hash_algo x_hash,
70 const infinint & min_digits,
71 bool format_07_compatible
72 );
73
74
76 trivial_sar(const std::shared_ptr<user_interaction> & dialog,
77 const std::string & pipename,
78 bool lax
79 );
80
81 trivial_sar(const std::shared_ptr<user_interaction> & dialog,
82 int filedescriptor,
83 bool lax
84 );
85
87 trivial_sar(const std::shared_ptr<user_interaction> & dialog,
88 generic_file * f,
89 const label & internal_name,
90 const label & data_name,
91 bool format_07_compatible,
92 const std::string & execute
93 );
94
96 trivial_sar(const trivial_sar & ref) = delete;
97
99 trivial_sar(trivial_sar && ref) noexcept = delete;
100
102 trivial_sar & operator = (const trivial_sar & ref) = delete;
103
105 trivial_sar & operator = (trivial_sar && ref) noexcept = delete;
106
109
110 virtual bool skippable(skippability direction, const infinint & amount) override { return reference->skippable(direction, amount); };
111 virtual bool skip(const infinint & pos) override;
112 virtual bool skip_to_eof() override { if(is_terminated()) throw SRC_BUG; return reference->skip_to_eof(); };
113 virtual bool skip_relative(S_I x) override;
114 virtual bool truncatable(const infinint & pos) const override { return reference->truncatable(offset + pos); };
115 virtual infinint get_position() const override { return cur_pos; };
116
117 // contextual inherited method
118 virtual bool is_an_old_start_end_archive() const override { return old_sar; };
119 virtual const label & get_data_name() const override { return of_data_name; };
120
122 const infinint & get_slice_header_size() const { return offset; };
123
126
129
130 protected:
131 virtual void inherited_read_ahead(const infinint & amount) override { reference->read_ahead(amount); };
132 virtual U_I inherited_read(char *a, U_I size) override;
133 virtual void inherited_write(const char *a, U_I size) override;
134 virtual void inherited_truncate(const infinint & pos) override { reference->truncate(pos + offset); cur_pos = pos; };
135 virtual void inherited_sync_write() override { if(reference != nullptr) reference->sync_write(); };
136 virtual void inherited_flush_read() override { if(reference != nullptr) reference->flush_read(); };
137 virtual void inherited_terminate() override;
138
139 private:
144 std::string hook;
145 std::string base;
146 std::string ext;
148 bool old_sar;
150 std::string hook_where;
151 std::string base_url;
153
154 void init(const label & internal_name);
155
156 void where_am_i();
157 };
158
159
161 extern std::string sar_make_filename(const std::string & base_name, const infinint & num, const infinint & min_digits, const std::string & ext);
162
164
165} // end of namespace
166
167#endif
the contextual class adds the information of phases in the generic_file
this is the interface class from which all other data transfer classes inherit
virtual bool truncatable(const infinint &pos) const =0
whether the implementation is able to truncate to the given position
virtual void truncate(const infinint &pos)
truncate file at the given offset
virtual bool skippable(skippability direction, const infinint &amount)=0
whether the implementation is able to skip
void read_ahead(const infinint &amount)
void flush_read()
be ready to read at current position, reseting all pending data for reading, cached and in compressio...
virtual bool skip_to_eof()=0
skip to the end of file
void sync_write()
write any pending data
the arbitrary large positive integer class
manage label data structure used in archive slice headers
Definition label.hpp:43
class mem_ui to keep a copy of a user_interaction object
void disable_natural_destruction()
disable execution of user command when destroying the current object
virtual bool skip(const infinint &pos) override
skip at the absolute position
label of_data_name
archive's data name
const infinint & get_slice_header_size() const
size of the slice header
trivial_sar(const std::shared_ptr< user_interaction > &dialog, const std::string &pipename, bool lax)
constructor to read a (single sliced) archive from a pipe
virtual void inherited_truncate(const infinint &pos) override
truncate file at the give offset
std::string hook
command to execute after slice writing (not used in read-only mode)
virtual void inherited_write(const char *a, U_I size) override
implementation of the write() operation
virtual void inherited_terminate() override
destructor-like call, except that it is allowed to throw exceptions
virtual void inherited_flush_read() override
reset internal engine, flush caches in order to read the data at current position
virtual bool truncatable(const infinint &pos) const override
whether the implementation is able to truncate to the given position
std::string hook_where
what value to use for p substitution in hook
void init(const label &internal_name)
write the slice header and set the offset field (write mode), or (read-mode), reads the slice header ...
virtual const label & get_data_name() const override
obtain the data_name of the archive (label associated with the archive's data)
infinint cur_pos
current position as returned by get_position()
infinint offset
offset to apply to get the first byte of data out of SAR headers
trivial_sar(const std::shared_ptr< user_interaction > &dialog, gf_mode open_mode, const std::string &base_name, const std::string &extension, const entrepot &where, const label &internal_nale, const label &data_name, const std::string &execute, bool allow_over, bool warn_over, bool force_permission, U_I permission, hash_algo x_hash, const infinint &min_digits, bool format_07_compatible)
constructor to build a new single sliced archive
generic_file * reference
points to the underlying data, owned by "this"
std::string base_url
what value to use for u substitution in hook
void enable_natural_destruction()
enable back execution of user command when destroying the current object
virtual void inherited_read_ahead(const infinint &amount) override
tells the object that several calls to read() will follow to probably obtain at least the given amoun...
std::string base
basename of the archive (used for string susbstitution in hook)
virtual bool skip_to_eof() override
skip to the end of file
virtual void inherited_sync_write() override
write down any pending data
virtual U_I inherited_read(char *a, U_I size) override
implementation of read() operation
virtual bool skippable(skippability direction, const infinint &amount) override
whether the implementation is able to skip
bool natural_destruction
whether user command is executed once the single sliced archive is completed (disable upon user inter...
virtual bool skip_relative(S_I x) override
skip relatively to the current position
trivial_sar(const std::shared_ptr< user_interaction > &dialog, generic_file *f, const label &internal_name, const label &data_name, bool format_07_compatible, const std::string &execute)
constructor to write a (single sliced) archive to a anonymous pipe
virtual bool is_an_old_start_end_archive() const override
returns whether the archive is a old archive (format < 8)
trivial_sar(const std::shared_ptr< user_interaction > &dialog, int filedescriptor, bool lax)
~trivial_sar()
destructor
infinint min_digits
minimum number of digits in slice name
trivial_sar(const trivial_sar &ref)=delete
copy constructor (disabled)
trivial_sar & operator=(const trivial_sar &ref)=delete
assignment operator (disabled)
bool old_sar
true if the read sar has an old header (format <= "07") or the to be written must keep a version 07 f...
trivial_sar(trivial_sar &&ref) noexcept=delete
move constructor
infinint end_of_slice
when end of slice/archive is met, there is an offset by 1 compared to the offset of reference....
virtual infinint get_position() const override
get the current read/write position
std::string ext
extension of the archive (used for string substitution in hook)
class contextual adds the information of phases in the generic_file
hash_algo
hashing algorithm available
std::string sar_make_filename(const std::string &base_name, const infinint &num, const infinint &min_digits, const std::string &ext)
return the name of a slice given the base_name, slice number and extension
gf_mode
generic_file openning modes
include macro defined by the configure script and some specific additional ones
libdar namespace encapsulate all libdar symbols
defines the entrepot interface.
class generic_file is defined here as well as class fichier
switch module to limitint (32 ou 64 bits integers) or infinint
are defined here basic integer types that tend to be portable
class mem_ui definition. This class is to be used as parent class to handle user_interaction object m...