archive_options.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// to contact the author : http://dar.linux.free.fr/email.html
/*********************************************************************/


#ifndef ARCHIVE_OPTIONS_HPP
#define ARCHIVE_OPTIONS_HPP

#include "../my_config.h"
#include "crypto.hpp"
#include "integers.hpp"
#include "mask.hpp"
#include "compressor.hpp"
#include "catalogue.hpp"
#include "criterium.hpp"
#include "hash_fichier.hpp"
#include "secu_string.hpp"
#include "nls_swap.hpp"

#include <string>

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





    class archive_options_read
    {
    public:
        archive_options_read();

            // 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_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_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_ref_slice_min_digits(infinint val) { x_ref_slice_min_digits = 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; };

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


    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;

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



    class archive_options_create
    {
    public:
            // default constructors and destructor.

        archive_options_create() { x_selection = x_subtree = x_ea_mask = x_compr_mask = x_backup_hook_file_mask = NULL; clear(); };
        archive_options_create(const archive_options_create & ref) { copy_from(ref); };
        const archive_options_create & operator = (const archive_options_create & ref) { destroy(); copy_from(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(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_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_slicing(const infinint & file_size, const infinint & first_file_size = 0)
        {
            x_file_size = file_size;
            if(first_file_size == 0)
                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_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_what_to_check(inode::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)
        {
            NLS_SWAP_IN;
            try
            {

#if FURTIVE_READ_MODE_AVAILABLE
                x_furtive_read = furtive_read;
                if(furtive_read)
                {
                    x_old_alter_atime = x_alter_atime;
                    x_alter_atime = true;
                        // this is required to avoid libdar manipulating ctime of inodes
                }
                else
                    x_alter_atime = x_old_alter_atime;
#else
                if(furtive_read)
                    throw Ecompilation(gettext("Furtive read mode"));
                x_furtive_read = false;
#endif
            }
            catch(...)
            {
                NLS_SWAP_OUT;
                throw;
            }
            NLS_SWAP_OUT;
        };

        void set_same_fs(bool same_fs) { x_same_fs = same_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_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };

        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) { x_hash = 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; };

            // getting methods

        archive *get_reference() const { return x_ref_arch; };
        const mask & get_selection() const { if(x_selection == NULL) throw SRC_BUG; return *x_selection; };
        const mask & get_subtree() const { if(x_subtree == NULL) 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; };
        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; };
        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 == NULL) 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 mask & get_compr_mask() const { if(x_compr_mask == NULL) 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; };
        inode::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; };
        bool get_snapshot() const { return x_snapshot; };
        bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };
        bool get_display_skipped() const { return x_display_skipped; };
        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; };

    private:
        archive *x_ref_arch; //< just contains the address of an existing object, no local copy of object is done here
        mask * x_selection;  //< points to a local copy of mask (must be allocated / releases by the archive_option_create object)
        mask * x_subtree;    //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
        bool x_allow_over;
        bool x_warn_over;
        bool x_info_details;
        infinint x_pause;
        bool x_empty_dir;
        compression x_compr_algo;
        U_I x_compression_level;
        infinint x_file_size;
        infinint x_first_file_size;
        mask * x_ea_mask;    //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
        std::string x_execute;
        crypto_algo x_crypto;
        secu_string x_pass;
        U_32 x_crypto_size;
        mask * x_compr_mask; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
        infinint x_min_compr_size;
        bool x_nodump;
        inode::comparison_fields x_what_to_check;
        infinint x_hourshift;
        bool x_empty;
        bool x_alter_atime;
        bool x_old_alter_atime; //< used to backup origina alter_atime value when activating furtive read mode
        bool x_furtive_read;
        bool x_same_fs;
        bool x_snapshot;
        bool x_cache_directory_tagging;
        bool x_display_skipped;
        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;

        void destroy();
        void copy_from(const archive_options_create & ref);
        void destroy_mask(mask * & ptr);
        void clean_mask(mask * & ptr);
        void check_mask(const mask & m);
    };







    class archive_options_isolate
    {
    public:
        archive_options_isolate() { clear(); };

        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_slicing(const infinint & file_size, const infinint & first_file_size = 0)
        {
            x_file_size = file_size;
            if(first_file_size == 0)
                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_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) { x_hash = hash; };

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

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



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

    private:
        bool x_allow_over;
        bool x_warn_over;
        bool x_info_details;
        infinint x_pause;
        compression x_algo;
        U_I x_compression_level;
        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;
        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;

    };




    class archive_options_merge
    {
    public:

        archive_options_merge() { x_selection = x_subtree = x_ea_mask = x_compr_mask = NULL; x_overwrite = NULL; clear(); };
        archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };
        const archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };
        ~archive_options_merge() { destroy(); };

        void clear();

            // setting methods

        void set_auxilliary_ref(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_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_slicing(const infinint & file_size, const infinint & first_file_size = 0)
        {
            x_file_size = file_size;
            if(first_file_size == 0)
                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_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_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };

        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) { x_hash = hash; };

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



            // getting methods

        archive * get_auxilliary_ref() const { return x_ref; };
        const mask & get_selection() const { if(x_selection == NULL) throw SRC_BUG; return *x_selection; };
        const mask & get_subtree() const { if(x_subtree == NULL) 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 == NULL) throw SRC_BUG; return *x_overwrite; };
        bool get_info_details() const { return x_info_details; };
        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; };
        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 == NULL) 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 mask & get_compr_mask() const { if(x_compr_mask == NULL) 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_display_skipped() const { return x_display_skipped; };
        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; };

    private:
        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;
        infinint x_pause;
        bool x_empty_dir;
        compression x_compr_algo;
        U_I x_compression_level;
        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;
        mask * x_compr_mask;
        infinint x_min_compr_size;
        bool x_empty;
        bool x_display_skipped;
        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;

        void destroy();
        void copy_from(const archive_options_merge & ref);
    };



    class archive_options_extract
    {
    public:
        archive_options_extract() { x_selection = x_subtree = x_ea_mask = NULL; x_overwrite = NULL; clear(); };
        archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };
        const archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };
        ~archive_options_extract() { destroy(); };

        void clear();

            // setting methods

        void set_selection(const mask & selection);

        void set_subtree(const mask & subtree);

        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_ea_mask(const mask & ea_mask);

        void set_flat(bool flat) { x_flat = flat; };

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

        void set_warn_remove_no_match(bool warn_remove_no_match) { x_warn_remove_no_match = warn_remove_no_match; };

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

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

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


        void set_dirty_behavior(bool ignore, bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };

        void set_overwriting_rules(const crit_action & over);


        void set_only_deleted(bool val) { x_only_deleted = val; };



        void set_ignore_deleted(bool val) { x_ignore_deleted = val; };


            // getting methods

        enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };

        const mask & get_selection() const { if(x_selection == NULL) throw SRC_BUG; return *x_selection; };
        const mask & get_subtree() const { if(x_subtree == NULL) throw SRC_BUG; return *x_subtree; };
        bool get_warn_over() const { return x_warn_over; };
        bool get_info_details() const { return x_info_details; };
        const mask & get_ea_mask() const { if(x_ea_mask == NULL) throw SRC_BUG; return *x_ea_mask; };
        bool get_flat() const { return x_flat; };
        inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
        bool get_warn_remove_no_match() const { return x_warn_remove_no_match; };
        bool get_empty() const { return x_empty; };
        bool get_display_skipped() const { return x_display_skipped; };
        bool get_empty_dir() const { return x_empty_dir; };
        t_dirty get_dirty_behavior() const { return x_dirty; }
        const crit_action & get_overwriting_rules() const { if(x_overwrite == NULL) throw SRC_BUG; return *x_overwrite; };
        bool get_only_deleted() const { return x_only_deleted; };
        bool get_ignore_deleted() const { return x_ignore_deleted; };

    private:
        mask * x_selection;
        mask * x_subtree;
        bool x_warn_over;
        bool x_info_details;
        mask * x_ea_mask;
        bool x_flat;
        inode::comparison_fields x_what_to_check;
        bool x_warn_remove_no_match;
        bool x_empty;
        bool x_display_skipped;
        bool x_empty_dir;
        t_dirty x_dirty;
        crit_action *x_overwrite;
        bool x_only_deleted;
        bool x_ignore_deleted;

        void destroy();
        void copy_from(const archive_options_extract & ref);
    };





    class archive_options_listing
    {
    public:
        archive_options_listing() { x_selection = x_subtree = NULL;  clear(); };
        archive_options_listing(const archive_options_listing & ref) { copy_from(ref); };
        const archive_options_listing & operator = (const archive_options_listing & ref) { destroy(); copy_from(ref); return *this; };
        ~archive_options_listing() { destroy(); };

        void clear();


        enum listformat
        {
            normal,   //< the tar-like listing (this is the default)
            tree,     //< the original dar's tree listing (for those that like forest)
            xml       //< the xml catalogue output
        };

            // setting methods

        void set_info_details(bool info_details) { x_info_details = info_details; };
        void set_list_mode(listformat list_mode) { x_list_mode = list_mode; };
        void set_selection(const mask & selection);
        void set_subtree(const mask & subtree);
        void set_filter_unsaved(bool filter_unsaved) { x_filter_unsaved = filter_unsaved; };
        void set_display_ea(bool display_ea) { x_display_ea = display_ea; };

            // getting methods

        bool get_info_details() const { return x_info_details; };
        listformat get_list_mode() const { return x_list_mode; };
        const mask & get_selection() const;
        const mask & get_subtree() const;
        bool get_filter_unsaved() const { return x_filter_unsaved; };
        bool get_display_ea() const { return x_display_ea; };

    private:
        bool x_info_details;
        listformat x_list_mode;
        mask * x_selection;
        mask * x_subtree;
        bool x_filter_unsaved;
        bool x_display_ea;

        void destroy();
        void copy_from(const archive_options_listing & ref);
    };




    class archive_options_diff
    {
    public:
        archive_options_diff() { x_selection = x_subtree = x_ea_mask = NULL; clear(); };
        archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
        const archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
        ~archive_options_diff() { destroy(); };

        void clear();

            // setting methods

        void set_selection(const mask & selection);

        void set_subtree(const mask & subtree);

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

        void set_ea_mask(const mask & ea_mask);

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


        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_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };

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

        void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };


            // getting methods

        const mask & get_selection() const { if(x_selection == NULL) throw SRC_BUG; return *x_selection; };
        const mask & get_subtree() const { if(x_subtree == NULL) throw SRC_BUG; return *x_subtree; };
        bool get_info_details() const { return x_info_details; };
        const mask & get_ea_mask() const { if(x_ea_mask == NULL) throw SRC_BUG; return *x_ea_mask; };
        inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
        bool get_alter_atime() const { return x_alter_atime; };
        bool get_furtive_read_mode() const { return x_furtive_read; };
        bool get_display_skipped() const { return x_display_skipped; };
        const infinint & get_hourshift() const { return x_hourshift; };
        bool get_compare_symlink_date() const { return x_compare_symlink_date; };

    private:
        mask * x_selection;
        mask * x_subtree;
        bool x_info_details;
        mask * x_ea_mask;
        inode::comparison_fields x_what_to_check;
        bool x_alter_atime;
        bool x_old_alter_atime;
        bool x_furtive_read;
        bool x_display_skipped;
        infinint x_hourshift;
        bool x_compare_symlink_date;

        void destroy();
        void copy_from(const archive_options_diff & ref);
    };





    class archive_options_test
    {
    public:
        archive_options_test() { x_selection = x_subtree = NULL; clear(); };
        archive_options_test(const archive_options_test & ref) { copy_from(ref); };
        const archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
        ~archive_options_test() { destroy(); };

        void clear();

            // setting methods

        void set_selection(const mask & selection);

        void set_subtree(const mask & subtree);

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

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

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


            // getting methods

        const mask & get_selection() const { if(x_selection == NULL) throw SRC_BUG; return *x_selection; };
        const mask & get_subtree() const { if(x_subtree == NULL) throw SRC_BUG; return *x_subtree; };
        bool get_info_details() const { return x_info_details; };
        bool get_empty() const { return x_empty; };
        bool get_display_skipped() const { return x_display_skipped; };

    private:
        mask * x_selection;
        mask * x_subtree;
        bool x_info_details;
        bool x_empty;
        bool x_display_skipped;

        void destroy();
        void copy_from(const archive_options_test & ref);
    };


} // end of namespace

#endif