crit_action.hpp

Go to the documentation of this file.

/*********************************************************************/
// 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 CRIT_ACTION_HPP
#define CRIT_ACTION_HPP

#include "../my_config.h"

#include <deque>

#include "criterium.hpp"

namespace libdar
{


    class cat_nomme;


    enum over_action_data
    {
    data_preserve,                     
    data_overwrite,                    
    data_preserve_mark_already_saved,  
    data_overwrite_mark_already_saved, 
    data_remove,                       
    data_undefined,                    
    data_ask                           
    };



    enum over_action_ea
    {
    EA_preserve,                     
    EA_overwrite,                    
    EA_clear,                        
        EA_preserve_mark_already_saved,  
        EA_overwrite_mark_already_saved, 
    EA_merge_preserve,               
    EA_merge_overwrite,              
    EA_undefined,                    
    EA_ask                           
    };




    class crit_action
    {
    public:
    crit_action() {};
    crit_action(const crit_action & ref) = default;
    crit_action(crit_action && ref) noexcept = default;
    crit_action & operator = (const crit_action & ref) = default;
    crit_action & operator = (crit_action && ref) noexcept = default;

    virtual ~crit_action() = default;


    virtual void get_action(const cat_nomme & first, const cat_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; };
    crit_constant_action(const crit_constant_action & ref) = default;
    crit_constant_action & operator = (const crit_constant_action & ref) = default;
    ~crit_constant_action() = default;


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

    private:
    over_action_data x_data;
    over_action_ea x_ea;
    };




    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 &)"); };
    testing(testing && ref) noexcept : crit_action(std::move(ref)) { nullifyptr(); move_from(std::move(ref)); };
    testing & operator = (const testing & ref) { free(); copy_from(ref); if(!check()) throw Ememory("testing::testing(const testing &)"); return *this; };
    testing & operator = (testing && ref) noexcept { crit_action::operator = (std::move(ref)); move_from(std::move(ref)); return *this; };
    ~testing() { free(); };


    virtual void get_action(const cat_nomme & first, const cat_nomme & second, over_action_data & data, over_action_ea & ea) const override
    {
        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);
    };

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

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

    void nullifyptr() noexcept { x_input = nullptr; x_go_true = x_go_false = nullptr; };
    void free() noexcept;
    void copy_from(const testing & ref);
    void move_from(testing && ref) noexcept;
    bool check() const; 
    };




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

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

    virtual void get_action(const cat_nomme & first, const cat_nomme & second, over_action_data & data, over_action_ea & ea) const override;

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

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

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


} // end of namespace

#endif