26 #ifndef ARCHIVE_OPTIONS_HPP 27 #define ARCHIVE_OPTIONS_HPP 29 #include "../my_config.h" 111 void set_input_pipe(
const std::string & input_pipe) { x_input_pipe = input_pipe; };
117 void set_output_pipe(
const std::string & output_pipe) { x_output_pipe = output_pipe; };
130 void set_execute(
const std::string & execute) { x_execute = execute; };
154 void set_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_read::set_entrepot",
"null entrepot pointer given in argument"); x_entrepot = entr; };
166 void set_external_catalogue(
const path & ref_chem,
const std::string & ref_basename) { x_ref_chem = ref_chem, x_ref_basename = ref_basename; external_cat =
true; };
190 void set_ref_execute(
const std::string & ref_execute) { x_ref_execute = ref_execute; };
198 void set_ref_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_read::set_ref_entrepot",
"null entrepot pointer given in argument"); x_ref_entrepot = entr; };
209 crypto_algo get_crypto_algo()
const {
return x_crypto; };
210 const secu_string & get_crypto_pass()
const {
return x_pass; };
211 U_32 get_crypto_size()
const {
return x_crypto_size; };
212 const std::string & get_input_pipe()
const {
return x_input_pipe; };
213 const std::string & get_output_pipe()
const {
return x_output_pipe; };
214 const std::string & get_execute()
const {
return x_execute; };
215 bool get_info_details()
const {
return x_info_details; };
216 bool get_lax()
const {
return x_lax; };
217 bool get_sequential_read()
const {
return x_sequential_read; };
218 infinint get_slice_min_digits()
const {
return x_slice_min_digits; };
219 const std::shared_ptr<entrepot> & get_entrepot()
const {
return x_entrepot; };
220 bool get_ignore_signature_check_failure()
const {
return x_ignore_signature_check_failure; };
221 bool get_multi_threaded()
const {
return x_multi_threaded; };
224 bool is_external_catalogue_set()
const {
return external_cat; };
225 const path & get_ref_path()
const;
226 const std::string & get_ref_basename()
const;
227 crypto_algo get_ref_crypto_algo()
const {
return x_ref_crypto; };
228 const secu_string & get_ref_crypto_pass()
const {
return x_ref_pass; };
229 U_32 get_ref_crypto_size()
const {
return x_ref_crypto_size; };
230 const std::string & get_ref_execute()
const {
return x_ref_execute; };
231 infinint get_ref_slice_min_digits()
const {
return x_ref_slice_min_digits; };
232 const std::shared_ptr<entrepot> & get_ref_entrepot()
const {
return x_ref_entrepot; };
233 bool get_header_only()
const {
return x_header_only; };
240 std::string x_input_pipe;
241 std::string x_output_pipe;
242 std::string x_execute;
245 bool x_sequential_read;
247 std::shared_ptr<entrepot> x_entrepot;
248 bool x_ignore_signature_check_failure;
249 bool x_multi_threaded;
255 std::string x_ref_basename;
258 U_32 x_ref_crypto_size;
259 std::string x_ref_execute;
261 std::shared_ptr<entrepot> x_ref_entrepot;
299 void set_reference(std::shared_ptr<archive> ref_arch) { x_ref_arch = ref_arch; };
302 void set_selection(
const mask & selection);
305 void set_subtree(
const mask & subtree);
325 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
352 x_file_size = file_size;
353 if(first_file_size.is_zero())
354 x_first_file_size = file_size;
356 x_first_file_size = first_file_size;
361 void set_ea_mask(
const mask & ea_mask);
374 void set_execute(
const std::string & execute) { x_execute = execute; };
393 void set_gnupg_recipients(
const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
397 void set_gnupg_signatories(
const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
400 void set_compr_mask(
const mask & compr_mask);
411 { exclude_by_ea = (ea_name ==
"" ?
"user.libdar_no_backup" : ea_name); };
429 x_old_alter_atime = alter_atime;
431 x_alter_atime = alter_atime;
459 void set_retry_on_change(
const infinint & count_max_per_file,
const infinint & global_max_byte_overhead = 0) { x_repeat_count = count_max_per_file; x_repeat_byte = global_max_byte_overhead; };
483 void set_backup_hook(
const std::string & execute,
const mask & which_files);
489 void set_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_create::set_entrepot",
"null entrepot pointer given in argument"); x_entrepot = entr; };
506 void set_delta_mask(
const mask & delta_mask);
539 std::shared_ptr<archive> get_reference()
const {
return x_ref_arch; };
540 const mask & get_selection()
const {
if(x_selection ==
nullptr)
throw SRC_BUG;
return *x_selection; };
541 const mask & get_subtree()
const {
if(x_subtree ==
nullptr)
throw SRC_BUG;
return *x_subtree; };
542 bool get_allow_over()
const {
return x_allow_over; };
543 bool get_warn_over()
const {
return x_warn_over; };
544 bool get_info_details()
const {
return x_info_details; };
545 bool get_display_treated()
const {
return x_display_treated; };
546 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
547 bool get_display_skipped()
const {
return x_display_skipped; };
548 bool get_display_finished()
const {
return x_display_finished; };
549 const infinint & get_pause()
const {
return x_pause; };
550 bool get_empty_dir()
const {
return x_empty_dir; };
551 compression get_compression()
const {
return x_compr_algo; };
552 U_I get_compression_level()
const {
return x_compression_level; };
553 const infinint & get_slice_size()
const {
return x_file_size; };
554 const infinint & get_first_slice_size()
const {
return x_first_file_size; };
555 const mask & get_ea_mask()
const {
if(x_ea_mask ==
nullptr)
throw SRC_BUG;
return *x_ea_mask; };
556 const std::string & get_execute()
const {
return x_execute; };
557 crypto_algo get_crypto_algo()
const {
return x_crypto; };
558 const secu_string & get_crypto_pass()
const {
return x_pass; };
559 U_32 get_crypto_size()
const {
return x_crypto_size; };
560 const std::vector<std::string> & get_gnupg_recipients()
const {
return x_gnupg_recipients; };
561 const std::vector<std::string> & get_gnupg_signatories()
const {
return x_gnupg_signatories; };
562 const mask & get_compr_mask()
const {
if(x_compr_mask ==
nullptr)
throw SRC_BUG;
return *x_compr_mask; };
563 const infinint & get_min_compr_size()
const {
return x_min_compr_size; };
564 bool get_nodump()
const {
return x_nodump; };
565 const std::string & get_exclude_by_ea()
const {
return exclude_by_ea; };
567 const infinint & get_hourshift()
const {
return x_hourshift; };
568 bool get_empty()
const {
return x_empty; };
569 bool get_alter_atime()
const {
return x_alter_atime; };
570 bool get_furtive_read_mode()
const {
return x_furtive_read; };
571 bool get_same_fs()
const {
return x_same_fs; };
572 bool get_snapshot()
const {
return x_snapshot; };
573 bool get_cache_directory_tagging()
const {
return x_cache_directory_tagging; };
574 const infinint & get_fixed_date()
const {
return x_fixed_date; };
575 const std::string & get_slice_permission()
const {
return x_slice_permission; };
576 const std::string & get_slice_user_ownership()
const {
return x_slice_user_ownership; };
577 const std::string & get_slice_group_ownership()
const {
return x_slice_group_ownership; };
578 const infinint & get_repeat_count()
const {
return x_repeat_count; };
579 const infinint & get_repeat_byte()
const {
return x_repeat_byte; };
580 bool get_sequential_marks()
const {
return x_sequential_marks; };
581 infinint get_sparse_file_min_size()
const {
return x_sparse_file_min_size; };
582 bool get_security_check()
const {
return x_security_check; };
583 const std::string & get_user_comment()
const {
return x_user_comment; };
584 hash_algo get_hash_algo()
const {
return x_hash; };
585 infinint get_slice_min_digits()
const {
return x_slice_min_digits; };
586 const std::string & get_backup_hook_file_execute()
const {
return x_backup_hook_file_execute; };
587 const mask & get_backup_hook_file_mask()
const {
return *x_backup_hook_file_mask; };
588 bool get_ignore_unknown_inode_type()
const {
return x_ignore_unknown; };
589 const std::shared_ptr<entrepot> & get_entrepot()
const {
return x_entrepot; };
590 const fsa_scope & get_fsa_scope()
const {
return x_scope; };
591 bool get_multi_threaded()
const {
return x_multi_threaded; };
592 bool get_delta_diff()
const {
return x_delta_diff; };
593 bool get_delta_signature()
const {
return x_delta_signature; };
594 const mask & get_delta_mask()
const {
return *x_delta_mask; }
595 bool get_has_delta_mask_been_set()
const {
return has_delta_mask_been_set; };
596 const infinint & get_delta_sig_min_size()
const {
return x_delta_sig_min_size; };
597 bool get_auto_zeroing_neg_dates()
const {
return x_auto_zeroing_neg_dates; };
598 const std::set<std::string> & get_ignored_as_symlink()
const {
return x_ignored_as_symlink; };
600 const infinint & get_iteration_count()
const {
return x_iteration_count; };
601 hash_algo get_kdf_hash()
const {
return x_kdf_hash; };
611 bool x_display_treated;
612 bool x_display_treated_only_dir;
613 bool x_display_skipped;
614 bool x_display_finished;
618 U_I x_compression_level;
622 std::string x_execute;
626 std::vector<std::string> x_gnupg_recipients;
627 std::vector<std::string> x_gnupg_signatories;
631 std::string exclude_by_ea;
640 bool x_cache_directory_tagging;
642 std::string x_slice_permission;
643 std::string x_slice_user_ownership;
644 std::string x_slice_group_ownership;
647 bool x_sequential_marks;
649 bool x_security_check;
650 std::string x_user_comment;
653 mask * x_backup_hook_file_mask;
654 std::string x_backup_hook_file_execute;
655 bool x_ignore_unknown;
656 std::shared_ptr<entrepot> x_entrepot;
658 bool x_multi_threaded;
660 bool x_delta_signature;
662 bool has_delta_mask_been_set;
664 bool x_auto_zeroing_neg_dates;
665 std::set<std::string> x_ignored_as_symlink;
671 void nullifyptr() noexcept;
672 void destroy() noexcept;
675 void destroy_mask(
mask * & ptr);
676 void clean_mask(
mask * & ptr);
677 void check_mask(const
mask & m);
694 archive_options_isolate();
695 archive_options_isolate(
const archive_options_isolate & ref);
696 archive_options_isolate(archive_options_isolate && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
697 archive_options_isolate & operator = (
const archive_options_isolate & ref) { destroy(); copy_from(ref);
return *
this; };
698 archive_options_isolate & operator = (archive_options_isolate && ref) noexcept { move_from(std::move(ref));
return *
this; };
699 ~archive_options_isolate() { destroy(); };
732 x_file_size = file_size;
733 if(first_file_size.is_zero())
734 x_first_file_size = file_size;
736 x_first_file_size = first_file_size;
750 void set_execute(
const std::string & execute) { x_execute = execute; };
763 void set_gnupg_recipients(
const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
766 void set_gnupg_signatories(
const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
793 void set_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_isolated::set_entrepot",
"null entrepot pointer given in argument"); x_entrepot = entr; };
802 void set_delta_mask(
const mask & delta_mask);
821 bool get_allow_over()
const {
return x_allow_over; };
822 bool get_warn_over()
const {
return x_warn_over; };
823 bool get_info_details()
const {
return x_info_details; };
824 const infinint & get_pause()
const {
return x_pause; };
825 compression get_compression()
const {
return x_algo; };
826 U_I get_compression_level()
const {
return x_compression_level; };
827 const infinint & get_slice_size()
const {
return x_file_size; };
828 const infinint & get_first_slice_size()
const {
return x_first_file_size; };
829 const std::string & get_execute()
const {
return x_execute; };
830 crypto_algo get_crypto_algo()
const {
return x_crypto; };
831 const secu_string & get_crypto_pass()
const {
return x_pass; };
832 U_32 get_crypto_size()
const {
return x_crypto_size; };
833 const std::vector<std::string> & get_gnupg_recipients()
const {
return x_gnupg_recipients; };
834 const std::vector<std::string> & get_gnupg_signatories()
const {
return x_gnupg_signatories; };
835 bool get_empty()
const {
return x_empty; };
836 const std::string & get_slice_permission()
const {
return x_slice_permission; };
837 const std::string & get_slice_user_ownership()
const {
return x_slice_user_ownership; };
838 const std::string & get_slice_group_ownership()
const {
return x_slice_group_ownership; };
839 const std::string & get_user_comment()
const {
return x_user_comment; };
840 hash_algo get_hash_algo()
const {
return x_hash; };
841 infinint get_slice_min_digits()
const {
return x_slice_min_digits; };
842 bool get_sequential_marks()
const {
return x_sequential_marks; };
843 const std::shared_ptr<entrepot> & get_entrepot()
const {
return x_entrepot; };
844 bool get_multi_threaded()
const {
return x_multi_threaded; };
845 bool get_delta_signature()
const {
return x_delta_signature; };
846 const mask & get_delta_mask()
const {
return *x_delta_mask; }
847 bool get_has_delta_mask_been_set()
const {
return has_delta_mask_been_set; };
848 const infinint & get_delta_sig_min_size()
const {
return x_delta_sig_min_size; };
849 const infinint & get_iteration_count()
const {
return x_iteration_count; };
850 hash_algo get_kdf_hash()
const {
return x_kdf_hash; };
860 U_I x_compression_level;
863 std::string x_execute;
867 std::vector<std::string> x_gnupg_recipients;
868 std::vector<std::string> x_gnupg_signatories;
870 std::string x_slice_permission;
871 std::string x_slice_user_ownership;
872 std::string x_slice_group_ownership;
873 std::string x_user_comment;
876 bool x_sequential_marks;
877 std::shared_ptr<entrepot> x_entrepot;
878 bool x_multi_threaded;
879 bool x_delta_signature;
881 bool has_delta_mask_been_set;
887 void copy_from(
const archive_options_isolate & ref);
888 void move_from(archive_options_isolate && ref) noexcept;
889 void destroy() noexcept;
890 void nullifyptr() noexcept;
916 void set_auxiliary_ref(std::shared_ptr<archive> ref) { x_ref = ref; };
919 void set_selection(
const mask & selection);
922 void set_subtree(
const mask & subtree);
931 void set_overwriting_rules(
const crit_action & overwrite);
945 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
969 x_file_size = file_size;
970 if(first_file_size.is_zero())
971 x_first_file_size = file_size;
973 x_first_file_size = first_file_size;
977 void set_ea_mask(
const mask & ea_mask);
990 void set_execute(
const std::string & execute) { x_execute = execute; };
1004 void set_gnupg_recipients(
const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1007 void set_gnupg_signatories(
const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1010 void set_compr_mask(
const mask & compr_mask);
1049 void set_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_merge::set_entrepot",
"null entrepot pointer given in argument"); x_entrepot = entr; };
1065 void set_delta_mask(
const mask & delta_mask);
1085 std::shared_ptr<archive> get_auxiliary_ref()
const {
return x_ref; };
1086 const mask & get_selection()
const {
if(x_selection ==
nullptr)
throw SRC_BUG;
return *x_selection; };
1087 const mask & get_subtree()
const {
if(x_subtree ==
nullptr)
throw SRC_BUG;
return *x_subtree; };
1088 bool get_allow_over()
const {
return x_allow_over; };
1089 bool get_warn_over()
const {
return x_warn_over; };
1090 const crit_action & get_overwriting_rules()
const {
if(x_overwrite ==
nullptr)
throw SRC_BUG;
return *x_overwrite; };
1091 bool get_info_details()
const {
return x_info_details; };
1092 bool get_display_treated()
const {
return x_display_treated; };
1093 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
1094 bool get_display_skipped()
const {
return x_display_skipped; };
1095 const infinint & get_pause()
const {
return x_pause; };
1096 bool get_empty_dir()
const {
return x_empty_dir; };
1097 compression get_compression()
const {
return x_compr_algo; };
1098 U_I get_compression_level()
const {
return x_compression_level; };
1099 const infinint & get_slice_size()
const {
return x_file_size; };
1100 const infinint & get_first_slice_size()
const {
return x_first_file_size; };
1101 const mask & get_ea_mask()
const {
if(x_ea_mask ==
nullptr)
throw SRC_BUG;
return *x_ea_mask; };
1102 const std::string & get_execute()
const {
return x_execute; };
1103 crypto_algo get_crypto_algo()
const {
return x_crypto; };
1104 const secu_string & get_crypto_pass()
const {
return x_pass; };
1105 U_32 get_crypto_size()
const {
return x_crypto_size; };
1106 const std::vector<std::string> & get_gnupg_recipients()
const {
return x_gnupg_recipients; };
1107 const std::vector<std::string> & get_gnupg_signatories()
const {
return x_gnupg_signatories; };
1108 const mask & get_compr_mask()
const {
if(x_compr_mask ==
nullptr)
throw SRC_BUG;
return *x_compr_mask; };
1109 const infinint & get_min_compr_size()
const {
return x_min_compr_size; };
1110 bool get_empty()
const {
return x_empty; };
1111 bool get_keep_compressed()
const {
return x_keep_compressed; };
1112 const std::string & get_slice_permission()
const {
return x_slice_permission; };
1113 const std::string & get_slice_user_ownership()
const {
return x_slice_user_ownership; };
1114 const std::string & get_slice_group_ownership()
const {
return x_slice_group_ownership; };
1115 bool get_decremental_mode()
const {
return x_decremental; };
1116 bool get_sequential_marks()
const {
return x_sequential_marks; };
1117 infinint get_sparse_file_min_size()
const {
return x_sparse_file_min_size; };
1118 const std::string & get_user_comment()
const {
return x_user_comment; };
1119 hash_algo get_hash_algo()
const {
return x_hash; };
1120 infinint get_slice_min_digits()
const {
return x_slice_min_digits; };
1121 const std::shared_ptr<entrepot> & get_entrepot()
const {
return x_entrepot; };
1122 const fsa_scope & get_fsa_scope()
const {
return x_scope; };
1123 bool get_multi_threaded()
const {
return x_multi_threaded; };
1124 bool get_delta_signature()
const {
return x_delta_signature; };
1125 const mask & get_delta_mask()
const {
return *x_delta_mask; }
1126 bool get_has_delta_mask_been_set()
const {
return has_delta_mask_been_set; };
1127 const infinint & get_delta_sig_min_size()
const {
return x_delta_sig_min_size; };
1128 const infinint & get_iteration_count()
const {
return x_iteration_count; };
1129 hash_algo get_kdf_hash()
const {
return x_kdf_hash; };
1134 std::shared_ptr<archive> x_ref;
1140 bool x_info_details;
1141 bool x_display_treated;
1142 bool x_display_treated_only_dir;
1143 bool x_display_skipped;
1147 U_I x_compression_level;
1151 std::string x_execute;
1155 std::vector<std::string> x_gnupg_recipients;
1156 std::vector<std::string> x_gnupg_signatories;
1157 mask * x_compr_mask;
1160 bool x_keep_compressed;
1161 std::string x_slice_permission;
1162 std::string x_slice_user_ownership;
1163 std::string x_slice_group_ownership;
1165 bool x_sequential_marks;
1167 std::string x_user_comment;
1170 std::shared_ptr<entrepot> x_entrepot;
1172 bool x_multi_threaded;
1173 bool x_delta_signature;
1175 bool has_delta_mask_been_set;
1181 void destroy() noexcept;
1184 void nullifyptr() noexcept;
1196 enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };
1211 void set_selection(
const mask & selection);
1214 void set_subtree(
const mask & subtree);
1230 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1236 void set_ea_mask(
const mask & ea_mask);
1257 void set_dirty_behavior(
bool ignore,
bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };
1263 void set_overwriting_rules(
const crit_action & over);
1283 const mask & get_selection()
const {
if(x_selection ==
nullptr)
throw SRC_BUG;
return *x_selection; };
1284 const mask & get_subtree()
const {
if(x_subtree ==
nullptr)
throw SRC_BUG;
return *x_subtree; };
1285 bool get_warn_over()
const {
return x_warn_over; };
1286 bool get_info_details()
const {
return x_info_details; };
1287 bool get_display_treated()
const {
return x_display_treated; };
1288 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
1289 bool get_display_skipped()
const {
return x_display_skipped; };
1290 const mask & get_ea_mask()
const {
if(x_ea_mask ==
nullptr)
throw SRC_BUG;
return *x_ea_mask; };
1291 bool get_flat()
const {
return x_flat; };
1293 bool get_warn_remove_no_match()
const {
return x_warn_remove_no_match; };
1294 bool get_empty()
const {
return x_empty; };
1295 bool get_empty_dir()
const {
return x_empty_dir; };
1296 t_dirty get_dirty_behavior()
const {
return x_dirty; }
1297 const crit_action & get_overwriting_rules()
const {
if(x_overwrite ==
nullptr)
throw SRC_BUG;
return *x_overwrite; };
1298 bool get_only_deleted()
const {
return x_only_deleted; };
1299 bool get_ignore_deleted()
const {
return x_ignore_deleted; };
1300 const fsa_scope & get_fsa_scope()
const {
return x_scope; };
1306 bool x_info_details;
1307 bool x_display_treated;
1308 bool x_display_treated_only_dir;
1309 bool x_display_skipped;
1313 bool x_warn_remove_no_match;
1318 bool x_only_deleted;
1319 bool x_ignore_deleted;
1322 void destroy() noexcept;
1323 void nullifyptr() noexcept;
1346 virtual void clear();
1358 void set_selection(
const mask & selection);
1363 void set_subtree(
const mask & subtree);
1376 void set_user_slicing(
const infinint & slicing_first,
const infinint & slicing_others);
1387 bool get_info_details()
const {
return x_info_details; };
1388 const mask & get_selection()
const;
1389 const mask & get_subtree()
const;
1390 bool get_filter_unsaved()
const {
return x_filter_unsaved; };
1391 bool get_user_slicing(
infinint & slicing_first,
infinint & slicing_others)
const;
1392 bool get_slicing_location()
const {
return x_slicing_location; };
1393 bool get_display_ea()
const {
return x_display_ea; };
1396 bool x_info_details;
1399 bool x_filter_unsaved;
1402 bool x_slicing_location;
1405 void destroy() noexcept;
1406 void nullifyptr() noexcept;
1416 class archive_options_diff
1419 archive_options_diff() { nullifyptr();
clear(); };
1420 archive_options_diff(
const archive_options_diff & ref) { copy_from(ref); };
1421 archive_options_diff(archive_options_diff && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1422 archive_options_diff & operator = (
const archive_options_diff & ref) { destroy(); copy_from(ref);
return *
this; };
1423 archive_options_diff & operator = (archive_options_diff && ref) noexcept { move_from(std::move(ref));
return *
this; };
1424 ~archive_options_diff() { destroy(); };
1432 void set_selection(
const mask & selection);
1435 void set_subtree(
const mask & subtree);
1443 void set_info_details(
bool info_details) { x_info_details = info_details; };
1448 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1451 void set_display_skipped(
bool display_skipped) { x_display_skipped = display_skipped; };
1454 void set_ea_mask(
const mask & ea_mask);
1457 void set_what_to_check(
comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1463 void set_alter_atime(
bool alter_atime)
1466 x_old_alter_atime = alter_atime;
1468 x_alter_atime = alter_atime;
1472 void set_furtive_read_mode(
bool furtive_read);
1475 void set_hourshift(
const infinint & hourshift) { x_hourshift = hourshift; };
1478 void set_compare_symlink_date(
bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1481 void set_fsa_scope(
const fsa_scope & scope) { x_scope = scope; };
1487 const mask & get_selection()
const {
if(x_selection ==
nullptr)
throw SRC_BUG;
return *x_selection; };
1488 const mask & get_subtree()
const {
if(x_subtree ==
nullptr)
throw SRC_BUG;
return *x_subtree; };
1489 bool get_info_details()
const {
return x_info_details; };
1490 bool get_display_treated()
const {
return x_display_treated; };
1491 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
1492 bool get_display_skipped()
const {
return x_display_skipped; };
1493 const mask & get_ea_mask()
const {
if(x_ea_mask ==
nullptr)
throw SRC_BUG;
return *x_ea_mask; };
1495 bool get_alter_atime()
const {
return x_alter_atime; };
1496 bool get_furtive_read_mode()
const {
return x_furtive_read; };
1497 const infinint & get_hourshift()
const {
return x_hourshift; };
1498 bool get_compare_symlink_date()
const {
return x_compare_symlink_date; };
1499 const fsa_scope & get_fsa_scope()
const {
return x_scope; };
1504 bool x_info_details;
1505 bool x_display_treated;
1506 bool x_display_treated_only_dir;
1507 bool x_display_skipped;
1511 bool x_old_alter_atime;
1512 bool x_furtive_read;
1514 bool x_compare_symlink_date;
1517 void destroy() noexcept;
1518 void nullifyptr() noexcept;
1519 void copy_from(
const archive_options_diff & ref);
1520 void move_from(archive_options_diff && ref) noexcept;
1547 void set_selection(
const mask & selection);
1550 void set_subtree(
const mask & subtree);
1566 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1575 const mask & get_selection()
const {
if(x_selection ==
nullptr)
throw SRC_BUG;
return *x_selection; };
1576 const mask & get_subtree()
const {
if(x_subtree ==
nullptr)
throw SRC_BUG;
return *x_subtree; };
1577 bool get_info_details()
const {
return x_info_details; };
1578 bool get_display_treated()
const {
return x_display_treated; };
1579 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
1580 bool get_display_skipped()
const {
return x_display_skipped; };
1581 bool get_empty()
const {
return x_empty; };
1586 bool x_info_details;
1587 bool x_display_treated;
1588 bool x_display_treated_only_dir;
1589 bool x_display_skipped;
1592 void destroy() noexcept;
1593 void nullifyptr() noexcept;
1645 void set_display_treated(
bool display_treated,
bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1663 x_file_size = file_size;
1664 if(first_file_size.is_zero())
1665 x_first_file_size = file_size;
1667 x_first_file_size = first_file_size;
1681 void set_execute(
const std::string & execute) { x_execute = execute; };
1699 void set_gnupg_recipients(
const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1703 void set_gnupg_signatories(
const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1729 void set_entrepot(
const std::shared_ptr<entrepot> & entr) {
if(!entr)
throw Erange(
"archive_options_repair::set_entrepot",
"null entrepot pointer given in argument"); x_entrepot = entr; };
1738 bool get_allow_over()
const {
return x_allow_over; };
1739 bool get_warn_over()
const {
return x_warn_over; };
1740 bool get_info_details()
const {
return x_info_details; };
1741 bool get_display_treated()
const {
return x_display_treated; };
1742 bool get_display_treated_only_dir()
const {
return x_display_treated_only_dir; };
1743 bool get_display_skipped()
const {
return x_display_skipped; };
1744 bool get_display_finished()
const {
return x_display_finished; };
1745 const infinint & get_pause()
const {
return x_pause; };
1746 const infinint & get_slice_size()
const {
return x_file_size; };
1747 const infinint & get_first_slice_size()
const {
return x_first_file_size; };
1748 const std::string & get_execute()
const {
return x_execute; };
1749 crypto_algo get_crypto_algo()
const {
return x_crypto; };
1750 const secu_string & get_crypto_pass()
const {
return x_pass; };
1751 U_32 get_crypto_size()
const {
return x_crypto_size; };
1752 const std::vector<std::string> & get_gnupg_recipients()
const {
return x_gnupg_recipients; };
1753 const std::vector<std::string> & get_gnupg_signatories()
const {
return x_gnupg_signatories; };
1754 bool get_empty()
const {
return x_empty; };
1755 const std::string & get_slice_permission()
const {
return x_slice_permission; };
1756 const std::string & get_slice_user_ownership()
const {
return x_slice_user_ownership; };
1757 const std::string & get_slice_group_ownership()
const {
return x_slice_group_ownership; };
1758 const std::string & get_user_comment()
const {
return x_user_comment; };
1759 hash_algo get_hash_algo()
const {
return x_hash; };
1760 infinint get_slice_min_digits()
const {
return x_slice_min_digits; };
1761 const std::shared_ptr<entrepot> & get_entrepot()
const {
return x_entrepot; };
1762 bool get_multi_threaded()
const {
return x_multi_threaded; };
1767 bool x_info_details;
1768 bool x_display_treated;
1769 bool x_display_treated_only_dir;
1770 bool x_display_skipped;
1771 bool x_display_finished;
1775 std::string x_execute;
1779 std::vector<std::string> x_gnupg_recipients;
1780 std::vector<std::string> x_gnupg_signatories;
1782 std::string x_slice_permission;
1783 std::string x_slice_user_ownership;
1784 std::string x_slice_group_ownership;
1785 std::string x_user_comment;
1788 std::shared_ptr<entrepot> x_entrepot;
1789 bool x_multi_threaded;
1791 void nullifyptr() noexcept {};
comparison_fields
how to consider file change during comparison and incremental backup
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA are considered) ...
void set_auto_zeroing_neg_dates(bool val)
whether to automatically zeroing negative dates read from the filesystem (just warn, don't ask whether to pursue)
here lies a mask that selects files present in a given listThe mask_list classes defined here is to b...
defines the entrepot interface. Entrepot interface defines a generic way to interact with files (slic...
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_hash_algo(hash_algo hash)
void set_external_catalogue(const path &ref_chem, const std::string &ref_basename)
defines whether or not to use the catalogue from an extracted catalogue (instead of the one embedded ...
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_alter_atime(bool alter_atime)
whether to alter atime or ctime in the filesystem when reading files to save
filesystem specific attributes available families and fsa_scope definition
the generic class, parent of all masks
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_multi_threaded(bool val)
whether libdar is allowed to create several thread to work possilbiy faster on multicore CPU (need li...
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
void set_crypto_algo(crypto_algo crypto)
cypher to use
are defined here basic integer types that tend to be portable
void set_ignore_unknown_inode_type(bool val)
whether to ignore unknown inode types instead of issuing a warning
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_sequential_marks(bool sequential)
whether to activate escape sequence aka tape marks to allow sequential reading of the archive ...
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_crypto_pass(const secu_string &pass)
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_crypto_size(U_32 crypto_size)
the encryption block size to use to decrypt
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void check() const
check the sanity of the provided values
void set_decremental_mode(bool mode)
if set to true use a merging mode suitable to build a decremental backup from two full backups (see N...
void set_execute(const std::string &execute)
set the command to execute before reading each slice (empty string for no script) ...
void set_header_only(bool val)
whether we only read the archive header and exit
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_empty(bool empty)
whether to make a dry-run operation
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_delta_signature(bool val)
archive_options_read(const archive_options_read &ref)
the copy constructor, assignment operator and destructor
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
defines how to calculate delta signature block size based of file size to delta sign ...
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
exception used when a requested fearture has not beed activated at compilation time ...
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
void set_fixed_date(const infinint &fixed_date)
whether to ignore any archive of reference and only save file which modification is more recent that ...
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
class holding optional parameters used to test the structure coherence of an existing archive ...
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive ...
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
mask * x_subtree
points to a local copy of mask (must be allocated / releases by the archive_option_create objects) ...
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
void set_what_to_check(comparison_fields what_to_check)
set the fields to consider when comparing inodes with reference archive (see comparison_fields enumer...
void set_ignored_as_symlink(const std::set< std::string > &list)
provide a list of full path which if are symlinks will be considered as the inode they point to ...
void set_default_crypto_size()
set the encryption block size to the default value
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_exclude_by_ea(const std::string &ea_name)
nested namespace containing routines that give features activated at compile time ...
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
archive_options_read()
build an object and set options to their default values
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void clear()
reset all the options to their default values
void set_hourshift(const infinint &hourshift)
ignore differences of at most this integer number of hours while looking for changes in dates ...
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use to retrieve slices
void set_delta_sig_min_size(const infinint &val)
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
void set_crypto_pass(const secu_string &pass)
defines the password or passphrase to decrypt (unused if encryption is not set)
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
void set_pause(const infinint &pause)
Pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each slice...
the crypto algoritm definition
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_filter_unsaved(bool filter_unsaved)
whether to only show entries that have their data fully saved
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio...
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
set the list of recipients that will be able to read the archive
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio...
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
void set_display_ea(bool display_ea)
whether to fetch EA for listing
bool librsync() noexcept
returns whether delta compression is available and delta diff stuff with it
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_allow_over(bool allow_over)
whether overwritting is allowed
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_info_details(bool info_details)
whether the user needs detailed output of the operation
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
void set_ignore_signature_check_failure(bool val)
whether to warn (true) or ignore (false) signature failure (default is true)
void set_empty(bool empty)
whether to make a dry-run operation
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_display_treated(bool display_treated, bool only_dir)
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
void set_compression(compression algo)
the compression algorithm used
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_info_details(bool info_details)
void set_reference(std::shared_ptr< archive > ref_arch)
set the archive to take as reference (nullptr for a full backup)
void set_ref_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use to retrieve slices of the reference archive (where the external catalogue...
mask * x_compr_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects) ...
void set_empty(bool empty)
dry-run exectution if set to true
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive ...
void set_snapshot(bool snapshot)
whether to make an emtpy archive only referencing the current state of files in the filesystem ...
void set_ref_crypto_size(U_32 ref_crypto_size)
defines the crypto size for the reference catalogue
crypto_algo
the different cypher available for encryption (strong or weak)
void set_empty(bool empty)
defines whether we do a dry-run execution
void set_same_fs(bool same_fs)
whether to limit the backup to files located on the same filesystem as the directory taken as root of...
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
compression parameters for API
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA activated at com...
void set_crypto_pass(const secu_string &pass)
password / passphrase to encrypt the data with (empty string for interactive question) ...
void set_crypto_pass(const secu_string &pass)
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_ref_crypto_pass(const secu_string &ref_pass)
defines the pass for the reference catalogue
void set_info_details(bool info_details)
whether output should be verbosed –> to be moved to shell output
void set_compression_level(U_I compression_level)
the compression level (from 1 to 9)
void set_keep_compressed(bool keep_compressed)
make dar ignore the 'algo' argument and do not uncompress / compress files that are selected for merg...
the global action for overwriting
void set_crypto_size(U_32 crypto_size)
size of the encryption by block to use
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_warn_over(bool warn_over)
whether a warning shall be issued before overwriting
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
void set_compression(compression compr_algo)
set the compression algorithm to be used
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_slicing_location(bool val)
whether to calculate the slice location of each file
void set_iteration_count(const infinint &val)
key derivation
void set_iteration_count(const infinint &val)
key derivation
void set_cache_directory_tagging(bool cache_directory_tagging)
whether to consider the Cache Directory Tagging Standard
bool furtive_read() noexcept
returns whether libdar can support furtive read mode when run by privileged user
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
std::set< fsa_family > fsa_scope
set of fsa families
void set_info_details(bool info_details)
here lies a collection of mask classes
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
mask * x_ea_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects) ...
exception used to signal range error
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
void set_compression(compression compr_algo)
set the compression algorithm to be used
modified_data_detection
how to detect data has changed when some fields
void set_retry_on_change(const infinint &count_max_per_file, const infinint &global_max_byte_overhead=0)
how much time to retry saving a file if it changed while being read
void set_crypto_pass(const secu_string &pass)
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
void set_modified_data_detection(modified_data_detection val)
defines when to resave a file's data which inode metadata changed
void set_ref_slice_min_digits(infinint val)
defines the minim digit for slice number of the archive of reference (where the external catalogue is...
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
compression
the different compression algorithm available
void set_input_pipe(const std::string &input_pipe)
set the name of the input pipe to read data from (when basename is set to "-")
void set_delta_sig_min_size(const infinint &val)
whether to never calculate delta signature for files which size is smaller or equal to the given argu...
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_delta_sig_min_size(const infinint &val)
whether to never calculate delta signature for files which size is smaller or equal to the given argu...
class holding optional parameters used to create an archive
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_execute(const std::string &execute)
command to execute after each slice creation
void set_empty(bool empty)
whether to make a dry-run operation
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
void set_ref_crypto_algo(crypto_algo ref_crypto)
defines the crypto algo for the reference catalogue
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
class holding optional parameters used to list the contents of an existing archive ...
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
hash_algo
hashing algorithm available
bool x_old_alter_atime
used to backup origina alter_atime value when activating furtive read mode
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
the arbitrary large positive integer class
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
void unset_external_catalogue()
clear any reference to an external catalogue
void set_crypto_algo(crypto_algo val)
defines the the crypto cypher to use to read the archive (default is crypto_none) ...
void set_iteration_count(const infinint &val)
key derivation
void set_ref_execute(const std::string &ref_execute)
set the command to execute before reading each slice of the reference catalogue
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
contains classes that let the user define the policy for overwriting files
void set_multi_threaded(bool val)
whether libdar is allowed to created several thread to work possibily faster on multicore CPU (requir...
class holding optional parameters used to read an existing archive
void set_delta_diff(bool val)
whether binary delta has to be computed for differential/incremental backup
class holding optional parameters used to proceed to the merge operation
mask * x_selection
points to a local copy of mask (must be allocated / releases by the archive_option_create object) ...
std::shared_ptr< archive > x_ref_arch
just contains the address of an existing object, no local copy of object is done here ...
void set_output_pipe(const std::string &output_pipe)
set the name of the output pipe to send orders to (when basenale is set to "-")
void set_security_check(bool check)
whether to check for ctime changes since with the archive of reference
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
class holding optional parameters used to create an archive
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
void set_nodump(bool nodump)
defines whether to ignore files with the nodump flag set
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
this file contains the definition of secu_string class, a std::string like class but allocated in sec...
class holding optional parameters used to isolate an existing archive
libdar namespace encapsulate all libdar symbols
void set_display_treated(bool display_treated, bool only_dir)
void set_lax(bool val)
defines whether any archive coherence error, system error or media error lead to the abortion of the ...
set of datastructures used to interact with a catalogue object
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
bool nodump() noexcept
returns whether nodump flag support has been activated at compilation time
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
structure used to define how to select block size for delta signature
void set_sequential_read(bool val)
defines whether to try reading the archive sequentially (ala tar) or using the final catalogue ...
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
the class path is here to manipulate paths in the Unix notation: using'/'
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)