Disk ARchive  2.7.8
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-2022 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 
35 namespace libdar
36 {
37 
40 
42  class cat_nomme;
43 
45 
50 
51  class criterium
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;
90  crit_in_place_is_inode(const crit_in_place_is_inode & ref) = 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:
164  crit_in_place_is_new_hardlinked_inode & operator = (crit_in_place_is_new_hardlinked_inode && ref) noexcept = default;
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;
184  ~crit_in_place_data_more_recent() = 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;
248  crit_in_place_data_saved(const crit_in_place_data_saved & ref) = 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;
265  crit_in_place_data_dirty(const crit_in_place_data_dirty & ref) = 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;
299  crit_in_place_has_delta_sig(crit_in_place_has_delta_sig && ref) noexcept = 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;
302  ~crit_in_place_has_delta_sig() = 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;
316  crit_in_place_EA_present(const crit_in_place_EA_present & ref) = 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;
342  ~crit_in_place_EA_more_recent() = 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;
405  crit_in_place_EA_bigger(const crit_in_place_EA_bigger & ref) = 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 
440  class crit_same_type : public criterium
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
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 criterium * clone() const override
clone construction method
Definition: criterium.hpp:497
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 criterium * clone() const override
clone construction method
Definition: criterium.hpp:323
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
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 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:187
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 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:288
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 criterium * clone() const override
clone construction method
Definition: criterium.hpp:392
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
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