| Disk ARchive 2.8.4 Full featured and portable backup and archiving tool

Loading...
Searching...
No Matches
list_entry.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2026 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
27#ifndef LIST_ENTRY_HPP
28#define LIST_ENTRY_HPP
29
30#include <string>
31#include <set>
32
33#include "../my_config.h"
34#include "infinint.hpp"
35#include "deci.hpp"
36#include "compression.hpp"
37#include "integers.hpp"
38#include "datetime.hpp"
39#include "range.hpp"
40#include "cat_status.hpp"
41#include "ea.hpp"
42#include "fsa_family.hpp"
43
44 namespace libdar
45{
46
49
50 class crc;
51
59 class list_entry
60 {
61 public:
62 list_entry() { clear(); };
63 list_entry(const list_entry & ref) = default;
64 list_entry(list_entry && ref) = default;
65 list_entry & operator = (const list_entry & ref) = default;
66 list_entry & operator = (list_entry && ref) noexcept = default;
67 ~list_entry() = default;
68
70
74 bool is_eod() const { return type == 'z'; };
75
76 // methods for API users
77 // field that are not set are returned as empty string
78
79 const std::string & get_name() const { return my_name; };
80 unsigned char get_type() const { return type; };
81 bool is_dir() const { return type == 'd'; };
82 bool is_file() const { return type == 'f'; };
83 bool is_symlink() const { return type == 'l'; };
84 bool is_char_device() const { return type == 'c'; };
85 bool is_block_device() const { return type == 'b'; };
86 bool is_unix_socket() const { return type == 's'; };
87 bool is_named_pipe() const { return type == 'p'; };
88 bool is_hard_linked() const { return hard_link; };
89 bool is_removed_entry() const { return type == 'x'; };
90 bool is_door_inode() const { return type == 'o'; };
91 bool is_empty_dir() const { return empty_dir; };
92
93 unsigned char get_removed_type() const;
94
95 bool has_data_present_in_the_archive() const { return data_status == saved_status::saved || data_status == saved_status::delta; };
96 std::string get_data_flag() const;
97 saved_status get_data_status() const { return data_status; };
98
99 bool has_EA() const { return ea_status != ea_saved_status::none && ea_status != ea_saved_status::removed; };
100 bool has_EA_saved_in_the_archive() const { return ea_status == ea_saved_status::full; };
101 std::string get_ea_flag() const;
102 ea_saved_status get_ea_status() const { return ea_status; };
103
104 bool has_FSA() const { return fsa_status != fsa_saved_status::none; };
105 bool has_FSA_saved_in_the_archive() const { return fsa_status == fsa_saved_status::full; };
106 std::string get_fsa_flag() const;
107
108 std::string get_uid(bool try_resolving_name = false) const;
109 std::string get_gid(bool try_resolving_name = false) const;
110 std::string get_perm() const;
111
114 void set_fully_detailed_dates(bool mode) const { full_date = mode; };
115 std::string get_last_access() const;
116 std::string get_last_modif() const;
117 std::string get_last_change() const;
118 std::string get_removal_date() const;
119 time_t get_last_access_s() const { return datetime2time_t(last_access); };
120 time_t get_last_modif_s() const;
121 time_t get_last_change_s() const { return datetime2time_t(last_change); };
122 time_t get_removal_date_s() const;
123
125
129 void get_last_access(datetime::time_unit tu, time_t & second, time_t & fraction) const
130 { last_access.get_value(second, fraction, tu); }
131
133 void get_last_modif(datetime::time_unit tu, time_t & second, time_t & fraction) const
134 { last_modif.get_value(second, fraction, tu); }
135
137 void get_last_change(datetime::time_unit tu, time_t & second, time_t & fraction) const
138 { last_change.get_value(second, fraction, tu); }
139
140 std::string get_file_size(bool size_in_bytes = true) const;
141 std::string get_compression_ratio() const;
142 std::string get_compression_ratio_flag() const;
143 bool is_sparse() const { return sparse_file; };
144 std::string get_sparse_flag() const { return sparse_file ? "[X]" : "[ ]"; };
145 std::string get_compression_algo() const { return compression2string(compression_algo); };
146 bool is_dirty() const { return dirty; };
147 std::string get_link_target() const { return target; };
148 std::string get_major() const;
149 std::string get_minor() const;
150
152
156 const range & get_slices() const { return slices; };
157 bool has_delta_signature() const { return delta_sig; };
158 std::string get_delta_flag() const;
159
160
162
172 bool get_archive_offset_for_data(infinint & val) const { val = offset_for_data; return !val.is_zero(); };
173 bool get_archive_offset_for_data(U_64 & val) const;
174 std::string get_archive_offset_for_data() const { return offset_for_data.is_zero() ? "" : deci(offset_for_data).human(); };
175
177
180 bool get_storage_size_for_data(infinint & val) const { val = storage_size_for_data; return !val.is_zero(); };
181 bool get_storage_size_for_data(U_64 & val) const;
182 std::string get_storage_size_for_data(bool size_in_bytes = true) const;
183
185
189 bool get_archive_offset_for_EA(infinint & val) const { val = offset_for_EA; return !val.is_zero(); };
190 bool get_archive_offset_for_EA(U_64 & val) const;
191 std::string get_archive_offset_for_EA() const { return offset_for_EA.is_zero() ? "" : deci(offset_for_EA).human(); };
192
194 bool get_storage_size_for_EA(infinint & val) const { val = storage_size_for_EA; return !val.is_zero(); };
195 bool get_storage_size_for_EA(U_64 & val) const;
196 std::string get_storage_size_for_EA() const { return storage_size_for_EA.is_zero() ? "" : deci(storage_size_for_EA).human(); };
197
199
203 bool get_archive_offset_for_FSA(infinint & val) const { val = offset_for_FSA; return !val.is_zero(); };
204 bool get_archive_offset_for_FSA(U_64 & val) const;
205 std::string get_archive_offset_for_FSA() const { return offset_for_FSA.is_zero() ? "" : deci(offset_for_FSA).human(); };
206
208 bool get_storage_size_for_FSA(infinint & val) const { val = storage_size_for_FSA; return !val.is_zero(); };
209 bool get_storage_size_for_FSA(U_64 & val) const;
210 std::string get_storage_size_for_FSA() const { return storage_size_for_FSA.is_zero() ? "" : deci(storage_size_for_FSA).human(); };
211
213
215 void get_ea_reset_read() const { it_ea = ea.begin(); };
216
218
224 bool get_ea_read_next(std::string & key) const;
225
226 std::string get_etiquette() const { return deci(etiquette).human(); };
227
228 fsa_scope get_fsa_scope() const { return fsa_sc; };
229
230 std::string get_data_crc() const { return data_crc; };
231 std::string get_delta_patch_base_crc() const { return patch_base_crc; };
232 std::string get_delta_patch_result_crc() const { return patch_result_crc; };
233
234 // methods for libdar to setup the object
235
236 void set_name(const std::string & val) { my_name = val; };
237 void set_type(unsigned char val) { type = val; };
238 void set_removed_type(unsigned char val);
239 void set_hard_link(bool val) { hard_link = val; };
240 void set_uid(const infinint & val) { uid = val; };
241 void set_gid(const infinint & val) { gid = val; };
242 void set_perm(U_16 val) { perm = val; };
243 void set_last_access(const datetime & val) { last_access = val; };
244 void set_last_modif(const datetime & val) { last_modif = val; };
245 void set_removal_date(const datetime & val);
246 void set_saved_status(saved_status val) { data_status = val; };
247 void set_ea_status(ea_saved_status val) { ea_status = val; };
248 void set_last_change(const datetime & val) { last_change = val; };
249 void set_fsa_status(fsa_saved_status val) { fsa_status = val; };
250 void set_file_size(const infinint & val) { file_size = val; };
251 void set_is_sparse_file(bool val) { sparse_file = val; };
252 void set_compression_algo(compression val) { compression_algo = val; };
253 void set_dirtiness(bool val) { dirty = val; };
254 void set_link_target(const std::string & val) { target = val; };
255 void set_major(int val) { major = val; };
256 void set_minor(int val) { minor = val; };
257 void set_slices(const range & sl) { slices = sl; };
258 void set_delta_sig(bool val) { delta_sig = val; };
259 void set_archive_offset_for_data(const infinint & val) { offset_for_data = val; };
260 void set_storage_size_for_data(const infinint & val) { storage_size_for_data = val; };
261 void set_archive_offset_for_EA(const infinint & val) { offset_for_EA = val; };
262 void set_storage_size_for_EA(const infinint & val) { storage_size_for_EA = val; };
263 void set_archive_offset_for_FSA(const infinint & val) { offset_for_FSA = val; };
264 void set_storage_size_for_FSA(const infinint & val) { storage_size_for_FSA = val; };
265 void set_ea(const ea_attributs & arg);
266 void set_etiquette(const infinint & arg) { etiquette = arg; };
267 void set_fsa_scope(const fsa_scope & arg) { fsa_sc = arg; };
268 void set_data_crc(const crc & ptr);
269 void set_delta_patch_base_crc(const crc & ptr);
270 void set_delta_patch_result_crc(const crc & ptr);
271 void set_empty_dir(bool val) { if(!is_dir()) throw SRC_BUG; empty_dir = val; };
272
273 void clear();
274
275 private:
276 std::string my_name;
277 bool hard_link;
278 unsigned char type;
279 infinint uid;
280 infinint gid;
281 U_16 perm;
282 mutable bool full_date;
283 datetime last_access;
284 datetime last_modif;
285 saved_status data_status;
286 ea_saved_status ea_status;
287 datetime last_change;
288 fsa_saved_status fsa_status;
289 fsa_scope fsa_sc;
290 infinint file_size;
291 bool sparse_file;
292 compression compression_algo;
293 bool dirty;
294 std::string target;
295 int major;
296 int minor;
297 range slices;
298 bool delta_sig;
299 infinint offset_for_data;
300 infinint storage_size_for_data;
301 infinint offset_for_EA;
302 infinint storage_size_for_EA;
303 infinint offset_for_FSA;
304 infinint storage_size_for_FSA;
305 std::deque<std::string> ea;
306 mutable std::deque<std::string>::const_iterator it_ea;
307 infinint etiquette;
308 std::string data_crc;
309 std::string patch_base_crc;
310 std::string patch_result_crc;
311 bool empty_dir;
312
313 static time_t datetime2time_t(const datetime & val);
314 };
315
317
318} // end of namespace
319
320#endif
cat_status.hpp
the different status of data and EA
libdar::crc
pure virtual class defining interface of a CRC object
Definition crc.hpp:47
libdar::datetime
stores time information
Definition datetime.hpp:59
libdar::deci
decimal class, convert infinint from and to decimal represention
Definition deci.hpp:51
libdar::deci::human
std::string human() const
this produce a string from the decimal stored in the current object
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::list_entry::set_fully_detailed_dates
void set_fully_detailed_dates(bool mode) const
Definition list_entry.hpp:114
libdar::list_entry::get_archive_offset_for_FSA
bool get_archive_offset_for_FSA(infinint &val) const
offset in byte where to find the first byte of Filesystem Specific Attributes
Definition list_entry.hpp:203
libdar::list_entry::get_last_modif
void get_last_modif(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get the last modification date (see get_last_access() for details)
Definition list_entry.hpp:133
libdar::list_entry::get_storage_size_for_data
bool get_storage_size_for_data(infinint &val) const
amount of byte used to store the file's data
Definition list_entry.hpp:180
libdar::list_entry::get_ea_reset_read
void get_ea_reset_read() const
reset the reading of Extended Attributes names
Definition list_entry.hpp:215
libdar::list_entry::get_last_access
void get_last_access(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get last access time
Definition list_entry.hpp:129
libdar::list_entry::get_removal_date
std::string get_removal_date() const
for removed_entry only
libdar::list_entry::get_last_change
void get_last_change(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get the last change date (see get_last_access() for details)
Definition list_entry.hpp:137
libdar::list_entry::get_fsa_scope
fsa_scope get_fsa_scope() const
this is the hard-link ID, only valid for hard linked entries
Definition list_entry.hpp:228
libdar::list_entry::is_eod
bool is_eod() const
method used to know whether the returned entry signals a End of Directory
Definition list_entry.hpp:74
libdar::list_entry::last_modif
datetime last_modif
also used to store removal_date for removed entries
Definition list_entry.hpp:284
libdar::list_entry::etiquette
infinint etiquette
hard link identification
Definition list_entry.hpp:307
libdar::list_entry::target
std::string target
target[0] used to store signature of removed entry for removed entries
Definition list_entry.hpp:294
libdar::list_entry::get_storage_size_for_EA
bool get_storage_size_for_EA(infinint &val) const
amount of byte used to store the file's EA
Definition list_entry.hpp:194
libdar::list_entry::get_removed_type
unsigned char get_removed_type() const
valid only for removed_entries
libdar::list_entry::get_ea_read_next
bool get_ea_read_next(std::string &key) const
read the next Extended Attribute name
libdar::list_entry::get_storage_size_for_FSA
bool get_storage_size_for_FSA(infinint &val) const
amount of byte used to store the file's FSA
Definition list_entry.hpp:208
libdar::list_entry::get_slices
const range & get_slices() const
provides slice information
Definition list_entry.hpp:156
libdar::list_entry::get_removal_date_s
time_t get_removal_date_s() const
for removed_entry only
libdar::list_entry::get_archive_offset_for_EA
bool get_archive_offset_for_EA(infinint &val) const
offset in byte whert to find the first byte of Extended Attributes
Definition list_entry.hpp:189
libdar::list_entry::get_archive_offset_for_data
bool get_archive_offset_for_data(infinint &val) const
offset in byte where to find first byte of data
Definition list_entry.hpp:172
libdar::range
stores a range of integers or a set of ranges
Definition range.hpp:44
compression.hpp
compression parameters for API
datetime.hpp
this file contains the definition of class datetime that stores unix times in a portable way
deci.hpp
manages the decimal representation of infinint
ea.hpp
contains a set of routines to manage EA values associated to a file
fsa_family.hpp
filesystem specific attributes available families and fsa_scope definition
libdar::compression2string
std::string compression2string(compression c)
convert a compression to its string representation
libdar::fsa_scope
std::set< fsa_family > fsa_scope
set of fsa families
Definition fsa_family.hpp:70
libdar::compression
compression
the different compression algorithm available
Definition compression.hpp:46
libdar::infinint::is_zero
bool is_zero() const
libdar::fsa_saved_status
fsa_saved_status
FSA saved status for an entry.
Definition cat_status.hpp:73
libdar::saved_status
saved_status
data saved status for an entry
Definition cat_status.hpp:44
libdar::ea_saved_status
ea_saved_status
EA saved status for an entry.
Definition cat_status.hpp:55
libdar::fsa_saved_status::none
@ none
no FSA saved
Definition cat_status.hpp:74
libdar::fsa_saved_status::full
@ full
FSA saved.
Definition cat_status.hpp:76
libdar::saved_status::saved
@ saved
inode is saved in the archive
Definition cat_status.hpp:45
libdar::saved_status::delta
@ delta
inode is saved but as delta binary from the content (delta signature) of what was found in the archiv...
Definition cat_status.hpp:49
libdar::ea_saved_status::none
@ none
no EA present for this inode in filesystem
Definition cat_status.hpp:56
libdar::ea_saved_status::removed
@ removed
EA were present in the reference version, but not present anymore.
Definition cat_status.hpp:60
libdar::ea_saved_status::full
@ full
EA present in filesystem and attached to this inode.
Definition cat_status.hpp:59
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
integers.hpp
are defined here basic integer types that tend to be portable
my_config.h
include macro defined by the configure script and some specific additional ones
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
range.hpp
class than provide a way to manipulate and represent range of integer numbers (infinint)