Disk ARchive 2.7.10
Full featured and portable backup and archiving tool
criterium.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2023 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 CRITERIUM_HPP
27#define CRITERIUM_HPP
28
29#include "../my_config.h"
30
31#include <deque>
32#include "erreurs.hpp"
33#include "infinint.hpp"
34
35namespace libdar
36{
37
40
42 class cat_nomme;
43
45
50
52 {
53 public:
54 criterium() = default;
55 criterium(const criterium & ref) = default;
56 criterium(criterium && ref) noexcept = default;
57 criterium & operator = (const criterium & ref) = default;
58 criterium & operator = (criterium && ref) noexcept = default;
59 virtual ~criterium() noexcept(false) {};
60
62
66 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const = 0;
67
69
73 virtual criterium *clone() const = 0;
74 };
75
76 // //////////////////////////////////////////////////////////
77 // ////////// a set of criterium classes follows ////////////
78 // //////////////////////////////////////////////////////////
79
80
82
85
87 {
88 public:
89 crit_in_place_is_inode() = default;
91 crit_in_place_is_inode(crit_in_place_is_inode && ref) noexcept = default;
92 crit_in_place_is_inode & operator = (const crit_in_place_is_inode & ref) = default;
93 crit_in_place_is_inode & operator = (crit_in_place_is_inode && ref) noexcept = default;
94 ~crit_in_place_is_inode() = default;
95
96 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
97 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_inode(*this); };
98 };
99
100
102
104 {
105 public:
106 crit_in_place_is_dir() = default;
107 crit_in_place_is_dir(const crit_in_place_is_dir & ref) = default;
108 crit_in_place_is_dir(crit_in_place_is_dir && ref) noexcept = default;
109 crit_in_place_is_dir & operator = (const crit_in_place_is_dir & ref) = default;
110 crit_in_place_is_dir & operator = (crit_in_place_is_dir && ref) noexcept = default;
111 ~crit_in_place_is_dir() = default;
112
113 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
114 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_dir(*this); };
115 };
116
117
119
121 {
122 public:
123 crit_in_place_is_file() = default;
124 crit_in_place_is_file(const crit_in_place_is_file & ref) = default;
125 crit_in_place_is_file(crit_in_place_is_file && ref) noexcept = default;
126 crit_in_place_is_file & operator = (const crit_in_place_is_file & ref) = default;
127 crit_in_place_is_file & operator = (crit_in_place_is_file && ref) noexcept = default;
128 ~crit_in_place_is_file() = default;
129
130 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
131 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_file(*this); };
132 };
133
135
137
139 {
140 public:
144 crit_in_place_is_hardlinked_inode & operator = (const crit_in_place_is_hardlinked_inode & ref) = default;
145 crit_in_place_is_hardlinked_inode & operator = (crit_in_place_is_hardlinked_inode && ref) noexcept = default;
147
148 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
149 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_hardlinked_inode(*this); };
150 };
151
152
156
158 {
159 public:
166
167 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
168 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_new_hardlinked_inode(*this); };
169 };
170
171
173
175
177 {
178 public:
179 crit_in_place_data_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};
182 crit_in_place_data_more_recent & operator = (const crit_in_place_data_more_recent & ref) = default;
183 crit_in_place_data_more_recent & operator = (crit_in_place_data_more_recent && ref) noexcept = default;
185
186 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
187 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_more_recent(*this); };
188
189 private:
190 infinint x_hourshift;
191 };
192
193
196
198
199
201 {
202 public:
203 crit_in_place_data_more_recent_or_equal_to(const infinint & date, const infinint & hourshift = 0) : x_hourshift(hourshift), x_date(date) {};
209
210 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
211 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_more_recent_or_equal_to(*this); };
212
213 private:
214 infinint x_hourshift;
215 infinint x_date;
216 };
217
218
220
222
224 {
225 public:
226 crit_in_place_data_bigger() = default;
228 crit_in_place_data_bigger(crit_in_place_data_bigger && ref) noexcept = default;
229 crit_in_place_data_bigger & operator = (const crit_in_place_data_bigger & ref) = default;
230 crit_in_place_data_bigger & operator = (crit_in_place_data_bigger && ref) noexcept = default;
231 ~crit_in_place_data_bigger() = default;
232
233 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
234 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_bigger(*this); };
235 };
236
237
238
241
243
245 {
246 public:
247 crit_in_place_data_saved() = default;
249 crit_in_place_data_saved(crit_in_place_data_saved && ref) noexcept = default;
250 crit_in_place_data_saved & operator = (const crit_in_place_data_saved & ref) = default;
251 crit_in_place_data_saved & operator = (crit_in_place_data_saved && ref) noexcept = default;
252 ~crit_in_place_data_saved() = default;
253
254 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
255 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_saved(*this); };
256 };
257
258
260
262 {
263 public:
264 crit_in_place_data_dirty() = default;
266 crit_in_place_data_dirty(crit_in_place_data_dirty && ref) noexcept = default;
267 crit_in_place_data_dirty & operator = (const crit_in_place_data_dirty & ref) = default;
268 crit_in_place_data_dirty & operator = (crit_in_place_data_dirty && ref) noexcept = default;
269 ~crit_in_place_data_dirty() = default;
270
271 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
272 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_dirty(*this); };
273 };
274
276
278 {
279 public:
280 crit_in_place_data_sparse() = default;
282 crit_in_place_data_sparse(crit_in_place_data_sparse && ref) noexcept = default;
283 crit_in_place_data_sparse & operator = (const crit_in_place_data_sparse & ref) = default;
284 crit_in_place_data_sparse & operator = (crit_in_place_data_sparse && ref) noexcept = default;
285 ~crit_in_place_data_sparse() = default;
286
287 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
288 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_sparse(*this); };
289 };
290
291
293
295 {
296 public:
297 crit_in_place_has_delta_sig() = default;
300 crit_in_place_has_delta_sig & operator = (const crit_in_place_has_delta_sig & ref) = default;
301 crit_in_place_has_delta_sig & operator = (crit_in_place_has_delta_sig && ref) noexcept = default;
303
304 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
305 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_has_delta_sig(*this); };
306 };
307
308
311
313 {
314 public:
315 crit_in_place_EA_present() = default;
317 crit_in_place_EA_present(crit_in_place_EA_present && ref) noexcept = default;
318 crit_in_place_EA_present & operator = (const crit_in_place_EA_present & ref) = default;
319 crit_in_place_EA_present & operator = (crit_in_place_EA_present && ref) noexcept = default;
320 ~crit_in_place_EA_present() = default;
321
322 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
323 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_present(*this); };
324 };
325
326
328
333
335 {
336 public:
337 crit_in_place_EA_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};
340 crit_in_place_EA_more_recent & operator = (const crit_in_place_EA_more_recent & ref) = default;
341 crit_in_place_EA_more_recent & operator = (crit_in_place_EA_more_recent && ref) noexcept = default;
343
344
345 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
346 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_more_recent(*this); };
347
348 private:
349 infinint x_hourshift;
350 };
351
352
354
357
359 {
360 public:
361 crit_in_place_EA_more_recent_or_equal_to(const infinint & date, const infinint & hourshift = 0) : x_hourshift(hourshift), x_date(date) {};
367
368 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
369 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_more_recent_or_equal_to(*this); };
370
371 private:
372 infinint x_hourshift;
373 infinint x_date;
374 };
375
376
378
380
382 {
383 public:
384 crit_in_place_more_EA() = default;
385 crit_in_place_more_EA(const crit_in_place_more_EA & ref) = default;
386 crit_in_place_more_EA(crit_in_place_more_EA && ref) noexcept = default;
387 crit_in_place_more_EA & operator = (const crit_in_place_more_EA & ref) = default;
388 crit_in_place_more_EA & operator = (crit_in_place_more_EA && ref) noexcept = default;
389 ~crit_in_place_more_EA() = default;
390
391 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
392 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_more_EA(*this); };
393 };
394
395
396
398
400
402 {
403 public:
404 crit_in_place_EA_bigger() = default;
406 crit_in_place_EA_bigger(crit_in_place_EA_bigger && ref) noexcept = default;
407 crit_in_place_EA_bigger & operator = (const crit_in_place_EA_bigger & ref) = default;
408 crit_in_place_EA_bigger & operator = (crit_in_place_EA_bigger && ref) noexcept = default;
409 ~crit_in_place_EA_bigger() = default;
410
411 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
412 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_bigger(*this); };
413 };
414
415
417
419
421 {
422 public:
423 crit_in_place_EA_saved() = default;
424 crit_in_place_EA_saved(const crit_in_place_EA_saved & ref) = default;
425 crit_in_place_EA_saved(crit_in_place_EA_saved && ref) noexcept = default;
426 crit_in_place_EA_saved & operator = (const crit_in_place_EA_saved & ref) = default;
427 crit_in_place_EA_saved & operator = (crit_in_place_EA_saved && ref) noexcept = default;
428 ~crit_in_place_EA_saved() = default;
429
430 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
431 virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_saved(*this); };
432 };
433
434
436
439
441 {
442 public:
443 crit_same_type() = default;
444 crit_same_type(const crit_same_type & ref) = default;
445 crit_same_type(crit_same_type && ref) noexcept = default;
446 crit_same_type & operator = (const crit_same_type & ref) = default;
447 crit_same_type & operator = (crit_same_type && ref) noexcept = default;
448 ~crit_same_type() = default;
449
450 virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
451 virtual criterium *clone() const override { return new (std::nothrow) crit_same_type(*this); };
452 };
453
454
456
457 class crit_not : public criterium
458 {
459 public:
460 crit_not(const criterium & crit) { x_crit = crit.clone(); if(x_crit == nullptr) throw Ememory("crit_not::crit_not"); };
461 crit_not(const crit_not & ref): criterium(ref) { copy_from(ref); };
462 crit_not(crit_not && ref) noexcept: criterium(std::move(ref)) { x_crit = nullptr; std::swap(x_crit, ref.x_crit); };
463 crit_not & operator = (const crit_not & ref) { destroy(); copy_from(ref); return *this; };
464 crit_not & operator = (crit_not && ref) noexcept { criterium::operator = (std::move(ref)); std::swap(x_crit, ref.x_crit); return *this; };
465 ~crit_not() { destroy(); };
466
467 virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override { return ! x_crit->evaluate(first, second); };
468 virtual criterium *clone() const override { return new (std::nothrow) crit_not(*this); };
469
470 protected:
471 const criterium *x_crit;
472
473 private:
474 void copy_from(const crit_not & ref);
475 void destroy() { if(x_crit != nullptr) { delete x_crit; x_crit = nullptr; } };
476 };
477
479
480 class crit_and : public criterium
481 {
482 public:
483 crit_and() { clear(); };
484 crit_and(const crit_and & ref) : criterium(ref) { copy_from(ref); };
485 crit_and(crit_and && ref) = default; // moving the deque<criterium *> while the pointed to object are untouched
486 crit_and & operator = (const crit_and & ref) { detruit(); copy_from(ref); return *this; };
487 crit_and & operator = (crit_and && ref) noexcept = default; // moving the deque<criterium *> while the pointed to object are untouched
488 ~crit_and() { detruit(); };
489
490 void add_crit(const criterium & ref);
491 void clear() { detruit(); };
492
494 void gobe(crit_and & to_be_voided);
495
496 virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override;
497 virtual criterium *clone() const override { return new (std::nothrow) crit_and(*this); };
498
499 protected:
500 std::deque<criterium *> operand;
501
502 private:
503 void copy_from(const crit_and & ref);
504 void detruit();
505 };
506
507 class crit_or : public crit_and
508 {
509 public:
510 crit_or() { clear(); };
511 crit_or(const crit_or & ref) = default;
512 crit_or(crit_or && ref) = default;
513 crit_or & operator = (const crit_or & ref) = default;
514 crit_or & operator = (crit_or && ref) noexcept = default;
515 ~crit_or() = default;
516
517 virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override;
518 virtual criterium *clone() const override { return new (std::nothrow) crit_or(*this); };
519
520 };
521
522 class crit_invert : public crit_not
523 {
524 public:
525 crit_invert(const criterium & crit) : crit_not(crit) {};
526 crit_invert(const crit_invert & ref) = default;
527 crit_invert(crit_invert && ref) noexcept = default;
528 crit_invert & operator = (const crit_invert & ref) = default;
529 crit_invert & operator = (crit_invert && ref) noexcept = default;
530 ~crit_invert() = default;
531
532 virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override { return x_crit->evaluate(second, first); };
533 virtual criterium *clone() const override { return new (std::nothrow) crit_invert(*this); };
534 };
535
537
538} // end of namespace
539
540#endif
exception used when memory has been exhausted
Definition: erreurs.hpp:127
the base class for all entry that have a name
Definition: cat_nomme.hpp:45
realises the AND operator
Definition: criterium.hpp:481
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:497
void gobe(crit_and &to_be_voided)
this call merges to the current call the arguments of another "crit_and", the given argument is clear...
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
returns true if the space used by EA of the first entry is greater or equal to the space used by the ...
Definition: criterium.hpp:402
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:412
returns true if the EA of the first entry is more recent or equal to the fixed date given in argument...
Definition: criterium.hpp:359
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:369
returns true if the EA of the first entry is more recent or equal to the one of the second entry
Definition: criterium.hpp:335
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:346
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:323
returns true if the in place entry has its EA saved (not just marked as saved) in the archve of refer...
Definition: criterium.hpp:421
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:431
returns true if the data of the first entry is bigger or equal to the one of the second entry
Definition: criterium.hpp:224
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:234
return true if the entry is a dirty file (or hard linked dirty file)
Definition: criterium.hpp:262
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:272
If the in_place entry is not an inode its date is considered equal to zero. Comparison is done on mti...
Definition: criterium.hpp:201
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:211
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
returns true if the data of the first entry is more recent or of the same date of the one of the seco...
Definition: criterium.hpp:177
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:187
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
if the entry is not an inode the result is also true
Definition: criterium.hpp:245
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:255
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
return true if the entry is a sparse file (or hard linked sparse file)
Definition: criterium.hpp:278
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:288
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
return true if the entry has delta signatur
Definition: criterium.hpp:295
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:305
returns true if the first entry is a cat_directory (whatever is the second)
Definition: criterium.hpp:104
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:114
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
returns true if the first entry is a plain file (whatever is the second)
Definition: criterium.hpp:121
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:131
returns true if the first entry is a inode with several hard links (whatever is the second entry)
Definition: criterium.hpp:139
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:149
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
returns true if the first entry is an inode (whatever is the second)
Definition: criterium.hpp:87
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:97
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:168
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
returns true if the first entry has more or even EA (in number not in size) than the second entry
Definition: criterium.hpp:382
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:392
realises the negation of the criterium given in argument to its constructor
Definition: criterium.hpp:458
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:468
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
Definition: criterium.hpp:467
returns true if the two entries are of the same type (plain-file/char dev/block dev/named pipe/symlin...
Definition: criterium.hpp:441
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:451
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
the generic criterium class, parent of all criterium
Definition: criterium.hpp:52
virtual criterium * clone() const =0
clone construction method
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const =0
criterum interface method
the arbitrary large positive integer class
contains all the excetion class thrown by libdar
switch module to limitint (32 ou 64 bits integers) or infinint
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47