Disk ARchive  2.6.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-2020 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 : http://dar.linux.free.fr/email.html
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
libdar::crit_in_place_is_file::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_EA_bigger
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:401
libdar::crit_in_place_data_sparse::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:288
libdar::crit_same_type::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_same_type
returns true if the two entries are of the same type (plain-file/char dev/block dev/named pipe/symlin...
Definition: criterium.hpp:440
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
libdar::infinint
the arbitrary large positive integer class
Definition: real_infinint.hpp:61
libdar::crit_in_place_is_new_hardlinked_inode::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:168
libdar::crit_in_place_data_more_recent_or_equal_to
If the in_place entry is not an inode its date is considered equal to zero. Comparison is done on mti...
Definition: criterium.hpp:200
libdar::crit_in_place_data_saved
if the entry is not an inode the result is also true
Definition: criterium.hpp:244
libdar::crit_in_place_is_hardlinked_inode::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:149
libdar::crit_in_place_EA_more_recent_or_equal_to::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:369
libdar::crit_in_place_EA_present
Definition: criterium.hpp:312
libdar::crit_in_place_is_hardlinked_inode
returns true if the first entry is a inode with several hard links (whatever is the second entry)
Definition: criterium.hpp:138
libdar::cat_nomme
the base class for all entry that have a name
Definition: cat_nomme.hpp:44
libdar::crit_and::gobe
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...
libdar::crit_in_place_is_inode::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:97
libdar::crit_in_place_EA_more_recent_or_equal_to::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_and::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:497
libdar::crit_in_place_EA_more_recent
returns true if the EA of the first entry is more recent or equal to the one of the second entry
Definition: criterium.hpp:334
libdar::crit_in_place_data_more_recent::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:187
libdar::criterium::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const =0
criterum interface method
libdar::crit_in_place_data_more_recent::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_is_new_hardlinked_inode::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_not::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
Definition: criterium.hpp:467
libdar::crit_in_place_has_delta_sig::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_same_type::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:451
libdar::crit_in_place_more_EA
returns true if the first entry has more or even EA (in number not in size) than the second entry
Definition: criterium.hpp:381
libdar::crit_in_place_data_dirty::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_is_inode::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_data_dirty
return true if the entry is a dirty file (or hard linked dirty file)
Definition: criterium.hpp:261
libdar::criterium
the generic criterium class, parent of all criterium
Definition: criterium.hpp:51
libdar::crit_in_place_EA_present::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:323
libdar::crit_in_place_EA_saved::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:431
libdar::crit_in_place_data_more_recent_or_equal_to::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_is_dir::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_data_sparse::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_is_hardlinked_inode::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
erreurs.hpp
contains all the excetion class thrown by libdar
libdar::crit_in_place_EA_saved
returns true if the in place entry has its EA saved (not just marked as saved) in the archve of refer...
Definition: criterium.hpp:420
libdar::criterium::clone
virtual criterium * clone() const =0
clone construction method
libdar::crit_in_place_EA_saved::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::Ememory
exception used when memory has been exhausted
Definition: erreurs.hpp:126
libdar::crit_in_place_more_EA::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:392
libdar::crit_in_place_data_bigger::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:234
libdar::crit_in_place_data_saved::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:255
libdar::crit_not::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:468
libdar::crit_in_place_is_inode
returns true if the first entry is an inode (whatever is the second)
Definition: criterium.hpp:86
libdar::crit_and
realises the AND operator
Definition: criterium.hpp:480
libdar::crit_in_place_has_delta_sig::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:305
libdar::crit_in_place_data_sparse
return true if the entry is a sparse file (or hard linked sparse file)
Definition: criterium.hpp:277
libdar::crit_in_place_EA_more_recent::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_data_saved::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_is_new_hardlinked_inode
Definition: criterium.hpp:157
libdar::crit_not
realises the negation of the criterium given in argument to its constructor
Definition: criterium.hpp:457
libdar::crit_in_place_data_more_recent
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:176
libdar::crit_in_place_has_delta_sig
return true if the entry has delta signatur
Definition: criterium.hpp:294
libdar::crit_in_place_is_dir
returns true if the first entry is a cat_directory (whatever is the second)
Definition: criterium.hpp:103
libdar::crit_in_place_is_file::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:131
libdar::crit_in_place_data_bigger::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_EA_bigger::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_EA_bigger::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:412
libdar::crit_in_place_more_EA::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_EA_more_recent_or_equal_to
returns true if the EA of the first entry is more recent or equal to the fixed date given in argument...
Definition: criterium.hpp:358
libdar::crit_in_place_EA_present::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_data_bigger
returns true if the data of the first entry is bigger or equal to the one of the second entry
Definition: criterium.hpp:223
libdar::crit_in_place_is_dir::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:114
libdar::crit_in_place_data_more_recent_or_equal_to::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:211
libdar::crit_in_place_EA_more_recent::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:346
libdar::crit_and::evaluate
virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override
criterum interface method
libdar::crit_in_place_data_dirty::clone
virtual criterium * clone() const override
clone construction method
Definition: criterium.hpp:272
libdar::crit_in_place_is_file
returns true if the first entry is a plain file (whatever is the second)
Definition: criterium.hpp:120
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:46