d/dar/dar-docs_2.7.15-2~bpo12+1_all.deb

/*********************************************************************/

// dar - disk archive - a backup/restoration program

// Copyright (C) 2002-2024 Denis Corbin

//

// This program is free software; you can redistribute it and/or

// modify it under the terms of the GNU General Public License

// as published by the Free Software Foundation; either version 2

// of the License, or (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

//

// to contact the author, see the AUTHOR file

/*********************************************************************/


#ifndef ARCHIVE_OPTIONS_HPP

#define ARCHIVE_OPTIONS_HPP


#include "../my_config.h"

#include "crypto.hpp"

#include "integers.hpp"

#include "mask.hpp"

#include "mask_list.hpp"

#include "crit_action.hpp"

#include "secu_string.hpp"

#include "entrepot.hpp"

#include "fsa_family.hpp"

#include "compile_time_features.hpp"

#include "archive_aux.hpp"

#include "compression.hpp"

#include "delta_sig_block_size.hpp"

#include "filesystem_ids.hpp"


#include <string>

#include <vector>

#include <set>

#include <memory>


namespace libdar

{

    class archive; // needed to be able to use pointer on archive object.


    class archive_options_read

    {

    public:

    archive_options_read();


    archive_options_read(const archive_options_read & ref) : x_ref_chem(ref.x_ref_chem) { copy_from(ref); };

    archive_options_read(archive_options_read && ref) noexcept;

    archive_options_read & operator = (const archive_options_read & ref) { copy_from(ref); return *this; };

    archive_options_read & operator = (archive_options_read && ref) noexcept { move_from(std::move(ref)); return *this; };

    ~archive_options_read() = default;


        // set back to default (this is the state just after the object is constructed

        // this method is to be used to reuse a given object


    void clear();


        // setting methods


    void set_crypto_algo(crypto_algo val) { x_crypto = val; };


    void set_crypto_pass(const secu_string & pass) { x_pass = pass; };


    void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };


    void set_default_crypto_size();


    void set_input_pipe(const std::string & input_pipe) { x_input_pipe = input_pipe; };


    void set_output_pipe(const std::string & output_pipe) { x_output_pipe = output_pipe; };


    void set_execute(const std::string & execute) { x_execute = execute; };


    void set_info_details(bool info_details) { x_info_details = info_details; };


    void set_lax(bool val) { x_lax = val; };


    void set_sequential_read(bool val) { x_sequential_read = val; };


    void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };


    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; };


    void set_ignore_signature_check_failure(bool val) { x_ignore_signature_check_failure = val; };


    void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };


    void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };


    void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };


    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; };

    void unset_external_catalogue();


    void set_ref_crypto_algo(crypto_algo ref_crypto) { x_ref_crypto = ref_crypto; };


    void set_ref_crypto_pass(const secu_string & ref_pass) { x_ref_pass = ref_pass; };


    void set_ref_crypto_size(U_32 ref_crypto_size) { x_ref_crypto_size = ref_crypto_size; };


    void set_ref_execute(const std::string & ref_execute) { x_ref_execute = ref_execute; };


    void set_ref_slice_min_digits(infinint val) { x_ref_slice_min_digits = val; };


    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; };


    void set_header_only(bool val) { x_header_only = val; };


        // getting methods (mainly used inside libdar, but kept public and part of the API in the case it is needed)


    crypto_algo get_crypto_algo() const { return x_crypto; };

    const secu_string & get_crypto_pass() const { return x_pass; };

    U_32 get_crypto_size() const { return x_crypto_size; };

    const std::string & get_input_pipe() const { return x_input_pipe; };

    const std::string & get_output_pipe() const { return x_output_pipe; };

    const std::string & get_execute() const { return x_execute; };

    bool get_info_details() const { return x_info_details; };

    bool get_lax() const { return x_lax; };

    bool get_sequential_read() const { return x_sequential_read; };

    infinint get_slice_min_digits() const { return x_slice_min_digits; };

    const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };

    bool get_ignore_signature_check_failure() const { return x_ignore_signature_check_failure; };

    U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };

    U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };


        // All methods that follow concern the archive where to fetch the (isolated) catalogue from

    bool is_external_catalogue_set() const { return external_cat; };

    const path & get_ref_path() const;

    const std::string & get_ref_basename() const;

    crypto_algo get_ref_crypto_algo() const { return x_ref_crypto; };

    const secu_string & get_ref_crypto_pass() const { return x_ref_pass; };

    U_32 get_ref_crypto_size() const { return x_ref_crypto_size; };

    const std::string & get_ref_execute() const { return x_ref_execute; };

    infinint get_ref_slice_min_digits() const { return x_ref_slice_min_digits; };

    const std::shared_ptr<entrepot> & get_ref_entrepot() const { return x_ref_entrepot; };

    bool get_header_only() const { return x_header_only; };


    private:

    crypto_algo x_crypto;

    secu_string x_pass;

    U_32 x_crypto_size;

    std::string x_input_pipe;

    std::string x_output_pipe;

    std::string x_execute;

    bool x_info_details;

    bool x_lax;

    bool x_sequential_read;

    infinint x_slice_min_digits;

    std::shared_ptr<entrepot> x_entrepot;

    bool x_ignore_signature_check_failure;

    U_I x_multi_threaded_crypto;

    U_I x_multi_threaded_compress;


        // external catalogue relative fields

    bool external_cat;

    path x_ref_chem;

    std::string x_ref_basename;

    crypto_algo x_ref_crypto;

    secu_string x_ref_pass;

    U_32 x_ref_crypto_size;

    std::string x_ref_execute;

    infinint x_ref_slice_min_digits;

    std::shared_ptr<entrepot> x_ref_entrepot;

    bool x_header_only;


    void copy_from(const archive_options_read & ref);

    void move_from(archive_options_read && ref) noexcept;

    };


    class archive_options_create

    {

    public:

        // default constructors and destructor.


    archive_options_create();

    archive_options_create(const archive_options_create & ref);

    archive_options_create(archive_options_create && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };

    archive_options_create & operator = (const archive_options_create & ref) { destroy(); copy_from(ref); return *this; };

    archive_options_create & operator = (archive_options_create && ref) noexcept { move_from(std::move(ref)); return *this; };

    ~archive_options_create() { destroy(); };


        // set back to default (this is the state just after the object is constructed

        // this method is to be used to reuse a given object


    void clear();


        // setting methods


    void set_reference(std::shared_ptr<archive> ref_arch) { x_ref_arch = ref_arch; };


    void set_selection(const mask & selection);


    void set_subtree(const mask & subtree);


    void set_allow_over(bool allow_over) { x_allow_over = allow_over; };


    void set_warn_over(bool warn_over) { x_warn_over = warn_over; };


    void set_info_details(bool info_details) { x_info_details = info_details; };


    void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };


    void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };


    void set_display_finished(bool display_finished) { x_display_finished = display_finished; };


    void set_pause(const infinint & pause) { x_pause = pause; };


    void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };


    void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };


    void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };


    void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };


    void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)

    {

        x_file_size = file_size;

        if(first_file_size.is_zero())

        x_first_file_size = file_size;

        else

        x_first_file_size = first_file_size;

    };


    void set_ea_mask(const mask & ea_mask);


    void set_execute(const std::string & execute) { x_execute = execute; };


    void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };


    void set_crypto_pass(const secu_string & pass) { x_pass = pass; };


    void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };


    void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };


    void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };


    void set_compr_mask(const mask & compr_mask);


    void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };


    void set_nodump(bool nodump) { x_nodump = nodump; };


    void set_exclude_by_ea(const std::string & ea_name)

    { exclude_by_ea = (ea_name == "" ? "user.libdar_no_backup" : ea_name); };


    void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };


    void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };


    void set_empty(bool empty) { x_empty = empty; };


    void set_alter_atime(bool alter_atime)

    {

        if(x_furtive_read)

        x_old_alter_atime = alter_atime;

        else

        x_alter_atime = alter_atime;

    };


    void set_furtive_read_mode(bool furtive_read);


    void set_same_fs(bool same_fs) { x_same_fs = same_fs; x_same_fs_include.clear(); x_same_fs_exclude.clear(); };


    void set_same_fs_include(const std::string & included_path_to_fs) { x_same_fs_include.push_back(included_path_to_fs); };


    void set_same_fs_exclude(const std::string & excluded_path_to_fs) { x_same_fs_exclude.push_back(excluded_path_to_fs); };


    void set_snapshot(bool snapshot) { x_snapshot = snapshot; };


    void set_cache_directory_tagging(bool cache_directory_tagging) { x_cache_directory_tagging = cache_directory_tagging; };


    void set_fixed_date(const infinint & fixed_date) { x_fixed_date = fixed_date; };


    void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };


    void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };


    void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };


    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; };


    void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };


    void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };


    void set_security_check(bool check) { x_security_check = check; };


    void set_user_comment(const std::string & comment) { x_user_comment = comment; };


    void set_hash_algo(hash_algo hash);


    void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };


    void set_backup_hook(const std::string & execute, const mask & which_files);


    void set_ignore_unknown_inode_type(bool val) { x_ignore_unknown = val; };


    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; };


    void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };


    void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };


    void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };


    void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };


    void set_delta_diff(bool val) { if(val && !compile_time::librsync()) throw Ecompilation("librsync"); x_delta_diff = val; };


    void set_delta_signature(bool val) { x_delta_signature = val; };


    void set_delta_mask(const mask & delta_mask);


    void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };


    void set_auto_zeroing_neg_dates(bool val) { x_auto_zeroing_neg_dates = val; };


    void set_ignored_as_symlink(const std::set<std::string> & list) { x_ignored_as_symlink = list; };


    void set_modified_data_detection(modified_data_detection val) { x_modified_data_detection = val; };


    void set_iteration_count(const infinint & val) { x_iteration_count = val; };


    void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };


    void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };


        // getting methods


    std::shared_ptr<archive> get_reference() const { return x_ref_arch; };

    const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };

    const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };

    bool get_allow_over() const { return x_allow_over; };

    bool get_warn_over() const { return x_warn_over; };

    bool get_info_details() const { return x_info_details; };

    bool get_display_treated() const { return x_display_treated; };

    bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };

    bool get_display_skipped() const { return x_display_skipped; };

    bool get_display_finished() const { return x_display_finished; };

    const infinint & get_pause() const { return x_pause; };

    bool get_empty_dir() const { return x_empty_dir; };

    compression get_compression() const { return x_compr_algo; };

    U_I get_compression_level() const { return x_compression_level; };

    U_I get_compression_block_size() const { return x_compression_block_size; };

    const infinint & get_slice_size() const { return x_file_size; };

    const infinint & get_first_slice_size() const { return x_first_file_size; };

    const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };

    const std::string & get_execute() const { return x_execute; };

    crypto_algo get_crypto_algo() const { return x_crypto; };

    const secu_string & get_crypto_pass() const { return x_pass; };

    U_32 get_crypto_size() const { return x_crypto_size; };

    const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };

    const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };

    const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };

    const infinint & get_min_compr_size() const { return x_min_compr_size; };

    bool get_nodump() const { return x_nodump; };

    const std::string & get_exclude_by_ea() const { return exclude_by_ea; };

    comparison_fields get_comparison_fields() const { return x_what_to_check; };

    const infinint & get_hourshift() const { return x_hourshift; };

    bool get_empty() const { return x_empty; };

    bool get_alter_atime() const { return x_alter_atime; };

    bool get_furtive_read_mode() const { return x_furtive_read; };

    bool get_same_fs() const { return x_same_fs; };

    std::deque<std::string> get_same_fs_include() const { return x_same_fs_include; };

    std::deque<std::string> get_same_fs_exclude() const { return x_same_fs_exclude; };

    bool get_snapshot() const { return x_snapshot; };

    bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };

    const infinint & get_fixed_date() const { return x_fixed_date; };

    const std::string & get_slice_permission() const { return x_slice_permission; };

    const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };

    const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };

    const infinint & get_repeat_count() const { return x_repeat_count; };

    const infinint & get_repeat_byte() const { return x_repeat_byte; };

    bool get_sequential_marks() const { return x_sequential_marks; };

    infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };

    bool get_security_check() const { return  x_security_check; };

    const std::string & get_user_comment() const { return x_user_comment; };

    hash_algo get_hash_algo() const { return x_hash; };

    infinint get_slice_min_digits() const { return x_slice_min_digits; };

    const std::string & get_backup_hook_file_execute() const { return x_backup_hook_file_execute; };

    const mask & get_backup_hook_file_mask() const { return *x_backup_hook_file_mask; };

    bool get_ignore_unknown_inode_type() const { return x_ignore_unknown; };

    const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };

    const fsa_scope & get_fsa_scope() const { return x_scope; };

    U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };

    U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };

    bool get_delta_diff() const { return x_delta_diff; };

    bool get_delta_signature() const { return x_delta_signature; };

    const mask & get_delta_mask() const { return *x_delta_mask; }

    bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };

    const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };

    bool get_auto_zeroing_neg_dates() const { return x_auto_zeroing_neg_dates; };

    const std::set<std::string> & get_ignored_as_symlink() const { return x_ignored_as_symlink; };

    modified_data_detection get_modified_data_detection() const { return x_modified_data_detection; };

    const infinint & get_iteration_count() const { return x_iteration_count; };

    hash_algo get_kdf_hash() const { return x_kdf_hash; };

    delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };


    private:

    std::shared_ptr<archive> x_ref_arch;

    mask * x_selection;

    mask * x_subtree;

    bool x_allow_over;

    bool x_warn_over;

    bool x_info_details;

    bool x_display_treated;

    bool x_display_treated_only_dir;

    bool x_display_skipped;

    bool x_display_finished;

    infinint x_pause;

    bool x_empty_dir;

    compression x_compr_algo;

    U_I x_compression_level;

    U_I x_compression_block_size;

    infinint x_file_size;

    infinint x_first_file_size;

    mask * x_ea_mask;

    std::string x_execute;

    crypto_algo x_crypto;

    secu_string x_pass;

    U_32 x_crypto_size;

    std::vector<std::string> x_gnupg_recipients;

    std::vector<std::string> x_gnupg_signatories;

    mask * x_compr_mask;

    infinint x_min_compr_size;

    bool x_nodump;

    std::string exclude_by_ea;

    comparison_fields x_what_to_check;

    infinint x_hourshift;

    bool x_empty;

    bool x_alter_atime;

    bool x_old_alter_atime;

    bool x_furtive_read;

    bool x_same_fs;

    std::deque<std::string> x_same_fs_include;

    std::deque<std::string> x_same_fs_exclude;

    bool x_snapshot;

    bool x_cache_directory_tagging;

    infinint x_fixed_date;

    std::string x_slice_permission;

    std::string x_slice_user_ownership;

    std::string x_slice_group_ownership;

    infinint x_repeat_count;

    infinint x_repeat_byte;

    bool x_sequential_marks;

    infinint x_sparse_file_min_size;

    bool x_security_check;

    std::string x_user_comment;

    hash_algo x_hash;

    infinint x_slice_min_digits;

    mask * x_backup_hook_file_mask;

    std::string x_backup_hook_file_execute;

    bool x_ignore_unknown;

    std::shared_ptr<entrepot> x_entrepot;

    fsa_scope x_scope;

    U_I x_multi_threaded_crypto;

    U_I x_multi_threaded_compress;

    bool x_delta_diff;

    bool x_delta_signature;

    mask *x_delta_mask;

    bool has_delta_mask_been_set;

    infinint x_delta_sig_min_size;

    bool x_auto_zeroing_neg_dates;

    std::set<std::string> x_ignored_as_symlink;

    modified_data_detection x_modified_data_detection;

    infinint x_iteration_count;

    hash_algo x_kdf_hash;

    delta_sig_block_size x_sig_block_len;


    void nullifyptr() noexcept;

    void destroy() noexcept;

    void copy_from(const archive_options_create & ref);

    void move_from(archive_options_create && ref) noexcept;

    void destroy_mask(mask * & ptr);

    void clean_mask(mask * & ptr);

    void check_mask(const mask & m);

    };


    class archive_options_isolate

    {

    public:

    archive_options_isolate();

    archive_options_isolate(const archive_options_isolate & ref);

    archive_options_isolate(archive_options_isolate && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };

    archive_options_isolate & operator = (const archive_options_isolate & ref) { destroy(); copy_from(ref); return *this; };

    archive_options_isolate & operator = (archive_options_isolate && ref) noexcept { move_from(std::move(ref)); return *this; };

    ~archive_options_isolate() { destroy(); };


    void clear();


        // setting methods


    void set_allow_over(bool allow_over) { x_allow_over = allow_over; };


    void set_warn_over(bool warn_over) { x_warn_over = warn_over; };


    void set_info_details(bool info_details) { x_info_details = info_details; };


    void set_pause(const infinint & pause) { x_pause = pause; };


    void set_compression(compression algo) { x_algo = algo; };


    void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };


    void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };


    void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)

    {

        x_file_size = file_size;

        if(first_file_size.is_zero())

        x_first_file_size = file_size;

        else

        x_first_file_size = first_file_size;

    };


    void set_execute(const std::string & execute) { x_execute = execute; };


    void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };


    void set_crypto_pass(const secu_string & pass) { x_pass = pass; };


    void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };


    void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };


    void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };


    void set_empty(bool empty) { x_empty = empty; };


    void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };


    void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };


    void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };


    void set_user_comment(const std::string & comment) { x_user_comment = comment; };


    void set_hash_algo(hash_algo hash);


    void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };


    void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };


    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; };


    void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };


    void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };


    void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };


    void set_delta_signature(bool val) { x_delta_signature = val; };


    void set_delta_mask(const mask & delta_mask);


    void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };


    void set_iteration_count(const infinint & val) { x_iteration_count = val; };


    void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };


    void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };


        // getting methods


    bool get_allow_over() const { return x_allow_over; };

    bool get_warn_over() const { return x_warn_over; };

    bool get_info_details() const { return x_info_details; };

    const infinint & get_pause() const { return x_pause; };

    compression get_compression() const { return x_algo; };

    U_I get_compression_level() const { return x_compression_level; };

    U_I get_compression_block_size() const { return x_compression_block_size; };

    const infinint & get_slice_size() const { return x_file_size; };

    const infinint & get_first_slice_size() const { return x_first_file_size; };

    const std::string & get_execute() const { return x_execute; };

    crypto_algo get_crypto_algo() const { return x_crypto; };

    const secu_string & get_crypto_pass() const { return x_pass; };

    U_32 get_crypto_size() const { return x_crypto_size; };

    const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };

    const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };

    bool get_empty() const { return x_empty; };

    const std::string & get_slice_permission() const { return x_slice_permission; };

    const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };

    const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };

    const std::string & get_user_comment() const { return x_user_comment; };

    hash_algo get_hash_algo() const { return x_hash; };

    infinint get_slice_min_digits() const { return x_slice_min_digits; };

    bool get_sequential_marks() const { return x_sequential_marks; };

    const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };

    U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };

    U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };

    bool get_delta_signature() const { return x_delta_signature; };

    const mask & get_delta_mask() const { return *x_delta_mask; }

    bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };

    const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };

    const infinint & get_iteration_count() const { return x_iteration_count; };

    hash_algo get_kdf_hash() const { return x_kdf_hash; };

    delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };


    private:

    bool x_allow_over;

    bool x_warn_over;

    bool x_info_details;

    infinint x_pause;

    compression x_algo;

    U_I x_compression_level;

    U_I x_compression_block_size;

    infinint x_file_size;

    infinint x_first_file_size;

    std::string x_execute;

    crypto_algo x_crypto;

    secu_string x_pass;

    U_32 x_crypto_size;

    std::vector<std::string> x_gnupg_recipients;

    std::vector<std::string> x_gnupg_signatories;

    bool x_empty;

    std::string x_slice_permission;

    std::string x_slice_user_ownership;

    std::string x_slice_group_ownership;

    std::string x_user_comment;

    hash_algo x_hash;

    infinint x_slice_min_digits;

    bool x_sequential_marks;

    std::shared_ptr<entrepot> x_entrepot;

    U_I x_multi_threaded_crypto;

    U_I x_multi_threaded_compress;

    bool x_delta_signature;

    mask *x_delta_mask;

    bool has_delta_mask_been_set;

    infinint x_delta_sig_min_size;

    infinint x_iteration_count;

    hash_algo x_kdf_hash;

    delta_sig_block_size x_sig_block_len;


    void copy_from(const archive_options_isolate & ref);

    void move_from(archive_options_isolate && ref) noexcept;

    void destroy() noexcept;

    void nullifyptr() noexcept;

    };


    class archive_options_merge

    {

    public:


    archive_options_merge() { nullifyptr(); clear(); };

    archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };

    archive_options_merge(archive_options_merge && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };

    archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };

    archive_options_merge & operator = (archive_options_merge && ref) noexcept { move_from(std::move(ref)); return *this; };

    ~archive_options_merge() { destroy(); };


    void clear();


        // setting methods


    void set_auxiliary_ref(std::shared_ptr<archive> ref) { x_ref = ref; };


    void set_selection(const mask & selection);


    void set_subtree(const mask & subtree);


    void set_allow_over(bool allow_over) { x_allow_over = allow_over; };


    void set_warn_over(bool warn_over) { x_warn_over = warn_over; };


    void set_overwriting_rules(const crit_action & overwrite);


    void set_info_details(bool info_details) { x_info_details = info_details; };


    void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };


    void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };


    void set_pause(const infinint & pause) { x_pause = pause; };


    void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };


    void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };


    void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };


    void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };


    void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)

    {

        x_file_size = file_size;

        if(first_file_size.is_zero())

        x_first_file_size = file_size;

        else

        x_first_file_size = first_file_size;

    };


    void set_ea_mask(const mask & ea_mask);


    void set_execute(const std::string & execute) { x_execute = execute; };


    void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };


    void set_crypto_pass(const secu_string & pass) { x_pass = pass; };


    void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };


    void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };


    void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };


    void set_compr_mask(const mask & compr_mask);


    void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };


    void set_empty(bool empty) { x_empty = empty; };


    void set_keep_compressed(bool keep_compressed) { x_keep_compressed = keep_compressed; };


    void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };


    void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };


    void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };


    void set_decremental_mode(bool mode) { x_decremental = mode; };


    void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };


    void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };


    void set_user_comment(const std::string & comment) { x_user_comment = comment; };


    void set_hash_algo(hash_algo hash);


    void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };


    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; };


    void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };


    void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };


    void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };


    void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };


    void set_delta_signature(bool val) { x_delta_signature = val; };


    void set_delta_mask(const mask & delta_mask);


    void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };


    void set_iteration_count(const infinint & val) { x_iteration_count = val; };


    void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };


    void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };


        // getting methods


    std::shared_ptr<archive>  get_auxiliary_ref() const { return x_ref; };

    const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };

    const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };

    bool get_allow_over() const { return x_allow_over; };

    bool get_warn_over() const { return x_warn_over; };

    const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };

    bool get_info_details() const { return x_info_details; };

    bool get_display_treated() const { return x_display_treated; };

    bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };

    bool get_display_skipped() const { return x_display_skipped; };

    const infinint & get_pause() const { return x_pause; };

    bool get_empty_dir() const { return x_empty_dir; };

    compression get_compression() const { return x_compr_algo; };

    U_I get_compression_level() const { return x_compression_level; };

    U_I get_compression_block_size() const { return x_compression_block_size; };

    const infinint & get_slice_size() const { return x_file_size; };

    const infinint & get_first_slice_size() const { return x_first_file_size; };

    const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };

    const std::string & get_execute() const { return x_execute; };

    crypto_algo get_crypto_algo() const { return x_crypto; };

    const secu_string & get_crypto_pass() const { return x_pass; };

    U_32 get_crypto_size() const { return x_crypto_size; };

    const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };

    const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };

    const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };

    const infinint & get_min_compr_size() const { return x_min_compr_size; };

    bool get_empty() const { return x_empty; };

    bool get_keep_compressed() const { return x_keep_compressed; };

    const std::string & get_slice_permission() const { return x_slice_permission; };

    const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };

    const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };

    bool get_decremental_mode() const { return x_decremental; };

    bool get_sequential_marks() const { return x_sequential_marks; };

    infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };

    const std::string & get_user_comment() const { return x_user_comment; };

    hash_algo get_hash_algo() const { return x_hash; };

    infinint get_slice_min_digits() const { return x_slice_min_digits; };

    const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };

    const fsa_scope & get_fsa_scope() const { return x_scope; };

    U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };

    U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };

    bool get_delta_signature() const { return x_delta_signature; };

    const mask & get_delta_mask() const { return *x_delta_mask; }

    bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };

    const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };

    const infinint & get_iteration_count() const { return x_iteration_count; };

    hash_algo get_kdf_hash() const { return x_kdf_hash; };

    delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };


    private:

    std::shared_ptr<archive> x_ref;

    mask * x_selection;

    mask * x_subtree;

    bool x_allow_over;

    bool x_warn_over;

    crit_action * x_overwrite;

    bool x_info_details;

    bool x_display_treated;

    bool x_display_treated_only_dir;

    bool x_display_skipped;

    infinint x_pause;

    bool x_empty_dir;

    compression x_compr_algo;

    U_I x_compression_level;

    U_I x_compression_block_size;

    infinint x_file_size;

    infinint x_first_file_size;

    mask * x_ea_mask;

    std::string x_execute;

    crypto_algo x_crypto;

    secu_string x_pass;

    U_32 x_crypto_size;

    std::vector<std::string> x_gnupg_recipients;

    std::vector<std::string> x_gnupg_signatories;

    mask * x_compr_mask;

    infinint x_min_compr_size;

    bool x_empty;

    bool x_keep_compressed;

    std::string x_slice_permission;

    std::string x_slice_user_ownership;

    std::string x_slice_group_ownership;

    bool x_decremental;

    bool x_sequential_marks;

    infinint x_sparse_file_min_size;

    std::string x_user_comment;

    hash_algo x_hash;

    infinint x_slice_min_digits;

    std::shared_ptr<entrepot> x_entrepot;

    fsa_scope x_scope;

    U_I x_multi_threaded_crypto;

    U_I x_multi_threaded_compress;

    bool x_delta_signature;

    mask *x_delta_mask;

    bool has_delta_mask_been_set;

    infinint x_delta_sig_min_size;

    infinint x_iteration_count;

    hash_algo x_kdf_hash;

    delta_sig_block_size x_sig_block_len;


    void destroy() noexcept;

    void copy_from(const archive_options_merge & ref);

    void move_from(archive_options_merge && ref) noexcept;

    void nullifyptr() noexcept;

    };


    class archive_options_extract

    {

    public:

    enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };


    archive_options_extract() { nullifyptr(); clear(); };

    archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };

    archive_options_extract(archive_options_extract && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };

    archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };

    archive_options_extract & operator = (archive_options_extract & ref) { destroy(); copy_from(ref); archive_options_extract & ref) { destroy(destroy(); cooy_from(ref); ?span class="keywordflow">return*this; a;

9span class="lineno"> 1320 get_has_dn class="keyword">this; a;

return*this< class="comment">// All methods that follow concern te="l01320">
 sev>
 ine"> x_multi_threaded_crypto; };
    U_I get_mul5a7e">set_decremental_mode(bool  232    U_I get_mul5a