| Disk ARchive 2.6.12 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
86 class crit_in_place_is_inode : public criterium
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
103 class crit_in_place_is_dir : public criterium
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
120 class crit_in_place_is_file : public criterium
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
138 class crit_in_place_is_hardlinked_inode : public criterium
139 {
140 public:
141 crit_in_place_is_hardlinked_inode() = default;
142 crit_in_place_is_hardlinked_inode(const crit_in_place_is_hardlinked_inode & ref) = default;
143 crit_in_place_is_hardlinked_inode(crit_in_place_is_hardlinked_inode && ref) noexcept = default;
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;
146 ~crit_in_place_is_hardlinked_inode() = 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
157 class crit_in_place_is_new_hardlinked_inode : public criterium
158 {
159 public:
160 crit_in_place_is_new_hardlinked_inode() = default;
161 crit_in_place_is_new_hardlinked_inode(const crit_in_place_is_new_hardlinked_inode & ref) = default;
162 crit_in_place_is_new_hardlinked_inode(crit_in_place_is_new_hardlinked_inode && ref) noexcept = default;
163 crit_in_place_is_new_hardlinked_inode & operator = (const crit_in_place_is_new_hardlinked_inode & ref) = default;
164 crit_in_place_is_new_hardlinked_inode & operator = (crit_in_place_is_new_hardlinked_inode && ref) noexcept = default;
165 ~crit_in_place_is_new_hardlinked_inode() = 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
176 class crit_in_place_data_more_recent : public criterium
177 {
178 public:
179 crit_in_place_data_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};
180 crit_in_place_data_more_recent(const crit_in_place_data_more_recent & ref) = default;
181 crit_in_place_data_more_recent(crit_in_place_data_more_recent && ref) noexcept = default;
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
200 class crit_in_place_data_more_recent_or_equal_to : public criterium
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) {};
204 crit_in_place_data_more_recent_or_equal_to(const crit_in_place_data_more_recent_or_equal_to & ref) = default;
205 crit_in_place_data_more_recent_or_equal_to(crit_in_place_data_more_recent_or_equal_to && ref) noexcept = default;
206 crit_in_place_data_more_recent_or_equal_to & operator = (const crit_in_place_data_more_recent_or_equal_to & ref) = default;
207 crit_in_place_data_more_recent_or_equal_to & operator = (crit_in_place_data_more_recent_or_equal_to && ref) noexcept = default;
208 ~crit_in_place_data_more_recent_or_equal_to() = default;
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
223 class crit_in_place_data_bigger : public criterium
224 {
225 public:
226 crit_in_place_data_bigger() = default;
227 crit_in_place_data_bigger(const crit_in_place_data_bigger & ref) = 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
244 class crit_in_place_data_saved : public criterium
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
261 class crit_in_place_data_dirty : public criterium
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
277 class crit_in_place_data_sparse : public criterium
278 {
279 public:
280 crit_in_place_data_sparse() = default;
281 crit_in_place_data_sparse(const crit_in_place_data_sparse & ref) = 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
294 class crit_in_place_has_delta_sig : public criterium
295 {
296 public:
297 crit_in_place_has_delta_sig() = default;
298 crit_in_place_has_delta_sig(const crit_in_place_has_delta_sig & ref) = 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
312 class crit_in_place_EA_present : public criterium
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
334 class crit_in_place_EA_more_recent : public criterium
335 {
336 public:
337 crit_in_place_EA_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};
338 crit_in_place_EA_more_recent(const crit_in_place_EA_more_recent & ref) = default;
339 crit_in_place_EA_more_recent(crit_in_place_EA_more_recent && ref) noexcept = default;
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
358 class crit_in_place_EA_more_recent_or_equal_to : public criterium
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) {};
362 crit_in_place_EA_more_recent_or_equal_to(const crit_in_place_EA_more_recent_or_equal_to & ref) = default;
363 crit_in_place_EA_more_recent_or_equal_to(crit_in_place_EA_more_recent_or_equal_to && ref) noexcept = default;
364 crit_in_place_EA_more_recent_or_equal_to & operator = (const crit_in_place_EA_more_recent_or_equal_to & ref) = default;
365 crit_in_place_EA_more_recent_or_equal_to & operator = (crit_in_place_EA_more_recent_or_equal_to && ref) noexcept = default;
366 ~crit_in_place_EA_more_recent_or_equal_to() = default;
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
381 class crit_in_place_more_EA : public criterium
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
401 class crit_in_place_EA_bigger : public crit_in_place_more_EA
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
420 class crit_in_place_EA_saved : public criterium
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:402
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:441
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:62
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:201
libdar::crit_in_place_data_saved
if the entry is not an inode the result is also true
Definition: criterium.hpp:245
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:313
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:139
libdar::cat_nomme
the base class for all entry that have a name
Definition: cat_nomme.hpp:45
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:335
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:382
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:262
libdar::criterium
the generic criterium class, parent of all criterium
Definition: criterium.hpp:52
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:421
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:127
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:87
libdar::crit_and
realises the AND operator
Definition: criterium.hpp:481
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:278
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:158
libdar::crit_not
realises the negation of the criterium given in argument to its constructor
Definition: criterium.hpp:458
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:177
libdar::crit_in_place_has_delta_sig
return true if the entry has delta signatur
Definition: criterium.hpp:295
libdar::crit_in_place_is_dir
returns true if the first entry is a cat_directory (whatever is the second)
Definition: criterium.hpp:104
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:359
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:224
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:121
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47