criterium.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 CRITERIUM_HPP
#define CRITERIUM_HPP

#include "../my_config.h"

#include <new>

#include "catalogue.hpp"

namespace libdar
{



    enum over_action_data
    {
        data_preserve,                     //< do not overwrite (keep the 'in place' entry)
        data_overwrite,                    //< overwirte the 'in place' entry by the 'to be added' one
        data_preserve_mark_already_saved,  //< keep the 'in place' but mark it as already saved in the archive of reference
        data_overwrite_mark_already_saved, //< overwrite the 'in place' but mark the 'to be added' as already saved in the archive of reference
        data_remove,                       //< remove the original data/EA (file is completely deleted)
        data_undefined,                    //< action still undefined at this step of the evaluation
        data_ask                           //< ask for user decision about file's data
    };



    enum over_action_ea //< define the action to apply to each EA entry (not to the EA set of a particular inode)
    {
        EA_preserve,                     //< keep the EA of the 'in place' entry
        EA_overwrite,                    //< keep the EA of the 'to be added' entry
        EA_clear,                        //< drop the EA for the elected entry
        EA_preserve_mark_already_saved,  //< drop any EA but mark them as already saved in the archive of reference (ctime is the one of the 'in place' inode)
        EA_overwrite_mark_already_saved, //< drop any EA but mark them as already saved in the archive of reference (ctime is the one of the 'to be added' inode)
        EA_merge_preserve,               //< merge EA but do not overwrite existing EA of 'in place' by one of the same name of 'to be added' inode
        EA_merge_overwrite,              //< merge EA but if both inode share an EA with the same name, take keep the one of the 'to be added' inode
        EA_undefined,                    //< action still undefined at this step of the evaluation
        EA_ask                           //< ask for user decision about EA
    };




    class crit_action
    {
    public:
        virtual ~crit_action() {};


        virtual void get_action(const nomme & first, const nomme & second, over_action_data & data, over_action_ea & ea) const = 0;


        virtual crit_action *clone() const = 0;
    };




    class crit_constant_action : public crit_action
    {
    public:

        crit_constant_action(over_action_data data, over_action_ea ea) { x_data = data; x_ea = ea; };


        void get_action(const nomme & first, const nomme & second, over_action_data & data, over_action_ea & ea) const { data = x_data; ea = x_ea; };
        crit_action *clone() const { return new (std::nothrow) crit_constant_action(*this); };

    private:
        over_action_data x_data;
        over_action_ea x_ea;
    };





    class criterium
    {
    public:
        virtual ~criterium() {};


        virtual bool evaluate(const nomme &first, const nomme &second) const = 0;


        virtual criterium *clone() const = 0;

    protected:
        static const inode *get_inode(const nomme * arg);
    };





    class testing : public crit_action
    {
    public:

        testing(const criterium & input, const crit_action & go_true, const crit_action & go_false);
        testing(const testing & ref) : crit_action(ref) { copy_from(ref); if(!check()) throw Ememory("testing::testing(const testing &)"); };
        const testing & operator = (const testing & ref) { free(); copy_from(ref); if(!check()) throw Ememory("testing::testing(const testing &)"); };
        ~testing() { free(); };


        void get_action(const nomme & first, const nomme & second, over_action_data & data, over_action_ea & ea) const
        {
            if(x_input->evaluate(first, second))
                x_go_true->get_action(first, second, data, ea);
            else
                x_go_false->get_action(first, second, data, ea);
        };

        crit_action *clone() const { return new (std::nothrow) testing(*this); };

    private:
        criterium *x_input;
        crit_action *x_go_true;
        crit_action *x_go_false;

        void free();
        void copy_from(const testing & ref);
        bool check() const; //< returns false if an field is NULL
    };




    class crit_chain : public crit_action
    {
    public:
        crit_chain() { sequence.clear(); };
        crit_chain(const crit_chain & ref) : crit_action(ref) { copy_from(ref); };
        const crit_chain & operator = (const crit_chain & ref) { destroy(); copy_from(ref); return *this; };
        ~crit_chain() { destroy(); };

        void add(const crit_action & act);
        void clear() { destroy(); };
        void gobe(crit_chain & to_be_voided);

        void get_action(const nomme & first, const nomme & second, over_action_data & data, over_action_ea & ea) const;

        crit_action *clone() const { return new (std::nothrow) crit_chain(*this); };

    private:
        std::vector<crit_action *> sequence;

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





    class crit_in_place_is_inode : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const { return dynamic_cast<const inode *>(&first) != NULL || dynamic_cast<const mirage *>(&first) != NULL; };
        criterium *clone() const { return new (std::nothrow) crit_in_place_is_inode(*this); };
    };



    class crit_in_place_is_dir : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const { return dynamic_cast<const directory *>(&first) != NULL; };
        criterium *clone() const { return new (std::nothrow) crit_in_place_is_dir(*this); };
    };



    class crit_in_place_is_file : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_is_file(*this); };
    };



    class crit_in_place_is_hardlinked_inode : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const { return dynamic_cast<const mirage *>(&first) != NULL; };
        criterium *clone() const { return new (std::nothrow) crit_in_place_is_hardlinked_inode(*this); };
    };


    class crit_in_place_is_new_hardlinked_inode : public criterium
    {
        bool evaluate(const nomme &first, const nomme &second) const
        {
            const mirage * tmp = dynamic_cast<const mirage *>(&first);
            return tmp != NULL && tmp->is_first_mirage();
        };
        criterium *clone() const { return new (std::nothrow) crit_in_place_is_new_hardlinked_inode(*this); };
    };




    class crit_in_place_data_more_recent : public criterium
    {
    public:
        crit_in_place_data_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};

        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_more_recent(*this); };

    private:
        infinint x_hourshift;
    };





    class crit_in_place_data_more_recent_or_equal_to : public criterium
    {
    public:
        crit_in_place_data_more_recent_or_equal_to(const infinint & date, const infinint & hourshift = 0) : x_hourshift(hourshift), x_date(date) {};

        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_more_recent_or_equal_to(*this); };

    private:
        infinint x_hourshift;
        infinint x_date;
    };




    class crit_in_place_data_bigger : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_bigger(*this); };
    };





    class crit_in_place_data_saved : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_saved(*this); };
    };



    class crit_in_place_data_dirty : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_dirty(*this); };
    };


    class crit_in_place_data_sparse : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_data_sparse(*this); };
    };



    class crit_in_place_EA_present : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const
        {
            const inode *tmp = dynamic_cast<const inode *>(&first);
            return tmp != NULL && tmp->ea_get_saved_status() != inode::ea_none && tmp->ea_get_saved_status() != inode::ea_removed;
        };
        criterium *clone() const { return new (std::nothrow) crit_in_place_EA_present(*this); };
    };




    class crit_in_place_EA_more_recent : public criterium
    {
    public:
        crit_in_place_EA_more_recent(const infinint & hourshift = 0) : x_hourshift(hourshift) {};

        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_EA_more_recent(*this); };

    private:
        infinint x_hourshift;
    };




    class crit_in_place_EA_more_recent_or_equal_to : public criterium
    {
    public:
        crit_in_place_EA_more_recent_or_equal_to(const infinint & date, const infinint & hourshift = 0) : x_hourshift(hourshift), x_date(date) {};

        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_EA_more_recent_or_equal_to(*this); };

    private:
        infinint x_hourshift;
        infinint x_date;
    };




    class crit_in_place_more_EA : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_more_EA(*this); };
    };





    class crit_in_place_EA_bigger : public crit_in_place_more_EA
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_EA_bigger(*this); };
    };




    class crit_in_place_EA_saved : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_in_place_EA_saved(*this); };
    };




    class crit_same_type : public criterium
    {
    public:
        bool evaluate(const nomme &first, const nomme &second) const;
        criterium *clone() const { return new (std::nothrow) crit_same_type(*this); };
    };



    class crit_not : public criterium
    {
    public:
        crit_not(const criterium & crit) { x_crit = crit.clone(); if(x_crit == NULL) throw Ememory("crit_not::crit_not"); };
        crit_not(const crit_not & ref) : criterium (ref) { copy_from(ref); };
        const crit_not & operator = (const crit_not & ref) { destroy(); copy_from(ref); return *this; };
        ~crit_not() { destroy(); };

        bool evaluate(const nomme & first, const nomme & second) const { return ! x_crit->evaluate(first, second); };
        criterium *clone() const { return new (std::nothrow) crit_not(*this); };

    protected:
        const criterium *x_crit;

    private:
        void copy_from(const crit_not & ref);
        void destroy() { if(x_crit != NULL) { delete x_crit; x_crit = NULL; } };
    };


    class crit_and : public criterium
    {
    public:
        crit_and() { clear(); };
        crit_and(const crit_and & ref) : criterium(ref) { copy_from(ref); };
        const crit_and & operator = (const crit_and & ref) { detruit(); copy_from(ref); return *this; };
        ~crit_and() { detruit(); };

        void add_crit(const criterium & ref);
        void clear() { detruit(); };

        void gobe(crit_and & to_be_voided);

        virtual bool evaluate(const nomme & first, const nomme & second) const;
        criterium *clone() const { return new (std::nothrow) crit_and(*this); };

    protected:
        std::vector<criterium *> operand;

    private:
        void copy_from(const crit_and & ref);
        void detruit();
    };

    class crit_or : public crit_and
    {
    public:
        crit_or() { clear(); };

        bool evaluate(const nomme & first, const nomme & second) const;
        criterium *clone() const { return new (std::nothrow) crit_or(*this); };

    };

    class crit_invert : public crit_not
    {
    public:
        crit_invert(const criterium & crit) : crit_not(crit) {};

        bool evaluate(const nomme & first, const nomme & second) const { return x_crit->evaluate(second, first); };
        criterium *clone() const { return new (std::nothrow) crit_invert(*this); };
    };



    extern over_action_ea crit_ask_user_for_EA_action(user_interaction & dialog, const std::string & full_name, const entree *already_here, const entree *dolly);


    extern over_action_data crit_ask_user_for_data_action(user_interaction & dialog, const std::string & full_name, const entree *already_here, const entree *dolly);


    extern void crit_show_entry_info(user_interaction & dialog, const std::string & full_name, const entree *already_here, const entree *dolly);


} // end of namespace

#endif