criterium.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2025 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 CRITERIUM_HPP
#define CRITERIUM_HPP
 
#include "../my_config.h"
 
#include <deque>
#include "erreurs.hpp"
#include "infinint.hpp"
 
namespace libdar
{
 
 
    class cat_nomme;
 
 
 
    class criterium
    {
    public:
    criterium() {};
    criterium(const criterium & ref) = default;
    criterium(criterium && ref) noexcept = default;
    criterium & operator = (const criterium & ref) = default;
    criterium & operator = (criterium && ref) noexcept = default;
    virtual ~criterium() noexcept(false) {};
 
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const = 0;
 
 
    virtual criterium *clone() const = 0;
    };
 
    // //////////////////////////////////////////////////////////
    // ////////// a set of criterium classes follows ////////////
        // //////////////////////////////////////////////////////////
 
 
 
 
    class crit_in_place_is_inode : public criterium
    {
    public:
    crit_in_place_is_inode() {};
    crit_in_place_is_inode(const crit_in_place_is_inode & ref) = default;
    crit_in_place_is_inode(crit_in_place_is_inode && ref) noexcept = default;
    crit_in_place_is_inode & operator = (const crit_in_place_is_inode & ref) = default;
    crit_in_place_is_inode & operator = (crit_in_place_is_inode && ref) noexcept = default;
    ~crit_in_place_is_inode() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_inode(*this); };
    };
 
 
 
    class crit_in_place_is_dir : public criterium
    {
    public:
    crit_in_place_is_dir() {};
    crit_in_place_is_dir(const crit_in_place_is_dir & ref) = default;
    crit_in_place_is_dir(crit_in_place_is_dir && ref) noexcept = default;
    crit_in_place_is_dir & operator = (const crit_in_place_is_dir & ref) = default;
    crit_in_place_is_dir & operator = (crit_in_place_is_dir && ref) noexcept = default;
    ~crit_in_place_is_dir() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_dir(*this); };
    };
 
 
 
    class crit_in_place_is_file : public criterium
    {
    public:
    crit_in_place_is_file() {};
    crit_in_place_is_file(const crit_in_place_is_file & ref) = default;
    crit_in_place_is_file(crit_in_place_is_file && ref) noexcept = default;
    crit_in_place_is_file & operator = (const crit_in_place_is_file & ref) = default;
    crit_in_place_is_file & operator = (crit_in_place_is_file && ref) noexcept = default;
    ~crit_in_place_is_file() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_file(*this); };
    };
 
 
 
    class crit_in_place_is_hardlinked_inode : public criterium
    {
    public:
    crit_in_place_is_hardlinked_inode() {};
    crit_in_place_is_hardlinked_inode(const crit_in_place_is_hardlinked_inode & ref) = default;
    crit_in_place_is_hardlinked_inode(crit_in_place_is_hardlinked_inode && ref) noexcept = default;
    crit_in_place_is_hardlinked_inode & operator = (const crit_in_place_is_hardlinked_inode & ref) = default;
    crit_in_place_is_hardlinked_inode & operator = (crit_in_place_is_hardlinked_inode && ref) noexcept = default;
    ~crit_in_place_is_hardlinked_inode() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_hardlinked_inode(*this); };
    };
 
 
 
    class crit_in_place_is_new_hardlinked_inode : public criterium
    {
    public:
    crit_in_place_is_new_hardlinked_inode() {};
    crit_in_place_is_new_hardlinked_inode(const crit_in_place_is_new_hardlinked_inode & ref) = default;
    crit_in_place_is_new_hardlinked_inode(crit_in_place_is_new_hardlinked_inode && ref) noexcept = default;
    crit_in_place_is_new_hardlinked_inode & operator = (const crit_in_place_is_new_hardlinked_inode & ref) = default;
    crit_in_place_is_new_hardlinked_inode & operator = (crit_in_place_is_new_hardlinked_inode && ref) noexcept = default;
    ~crit_in_place_is_new_hardlinked_inode() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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) {};
    crit_in_place_data_more_recent(const crit_in_place_data_more_recent & ref) = default;
    crit_in_place_data_more_recent(crit_in_place_data_more_recent && ref) noexcept = default;
    crit_in_place_data_more_recent & operator = (const crit_in_place_data_more_recent & ref) = default;
    crit_in_place_data_more_recent & operator = (crit_in_place_data_more_recent && ref) noexcept = default;
    ~crit_in_place_data_more_recent() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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) {};
    crit_in_place_data_more_recent_or_equal_to(const crit_in_place_data_more_recent_or_equal_to & ref) = default;
    crit_in_place_data_more_recent_or_equal_to(crit_in_place_data_more_recent_or_equal_to && ref) noexcept = default;
    crit_in_place_data_more_recent_or_equal_to & operator = (const crit_in_place_data_more_recent_or_equal_to & ref) = default;
    crit_in_place_data_more_recent_or_equal_to & operator = (crit_in_place_data_more_recent_or_equal_to && ref) noexcept = default;
    ~crit_in_place_data_more_recent_or_equal_to() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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:
    crit_in_place_data_bigger() {};
    crit_in_place_data_bigger(const crit_in_place_data_bigger & ref) = default;
    crit_in_place_data_bigger(crit_in_place_data_bigger && ref) noexcept = default;
    crit_in_place_data_bigger & operator = (const crit_in_place_data_bigger & ref) = default;
    crit_in_place_data_bigger & operator = (crit_in_place_data_bigger && ref) noexcept = default;
    ~crit_in_place_data_bigger() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_bigger(*this); };
    };
 
 
 
 
 
    class crit_in_place_data_saved : public criterium
    {
    public:
    crit_in_place_data_saved() {};
    crit_in_place_data_saved(const crit_in_place_data_saved & ref) = default;
    crit_in_place_data_saved(crit_in_place_data_saved && ref) noexcept = default;
    crit_in_place_data_saved & operator = (const crit_in_place_data_saved & ref) = default;
    crit_in_place_data_saved & operator = (crit_in_place_data_saved && ref) noexcept = default;
    ~crit_in_place_data_saved() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_saved(*this); };
    };
 
 
 
    class crit_in_place_data_dirty : public criterium
    {
    public:
    crit_in_place_data_dirty() {};
    crit_in_place_data_dirty(const crit_in_place_data_dirty & ref) = default;
    crit_in_place_data_dirty(crit_in_place_data_dirty && ref) noexcept = default;
    crit_in_place_data_dirty & operator = (const crit_in_place_data_dirty & ref) = default;
    crit_in_place_data_dirty & operator = (crit_in_place_data_dirty && ref) noexcept = default;
    ~crit_in_place_data_dirty() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_dirty(*this); };
    };
 
 
    class crit_in_place_data_sparse : public criterium
    {
    public:
    crit_in_place_data_sparse() {};
    crit_in_place_data_sparse(const crit_in_place_data_sparse & ref) = default;
    crit_in_place_data_sparse(crit_in_place_data_sparse && ref) noexcept = default;
    crit_in_place_data_sparse & operator = (const crit_in_place_data_sparse & ref) = default;
    crit_in_place_data_sparse & operator = (crit_in_place_data_sparse && ref) noexcept = default;
    ~crit_in_place_data_sparse() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_data_sparse(*this); };
    };
 
 
 
    class crit_in_place_has_delta_sig : public criterium
    {
    public:
    crit_in_place_has_delta_sig() {};
    crit_in_place_has_delta_sig(const crit_in_place_has_delta_sig & ref) = default;
    crit_in_place_has_delta_sig(crit_in_place_has_delta_sig && ref) noexcept = default;
    crit_in_place_has_delta_sig & operator = (const crit_in_place_has_delta_sig & ref) = default;
    crit_in_place_has_delta_sig & operator = (crit_in_place_has_delta_sig && ref) noexcept = default;
    ~crit_in_place_has_delta_sig() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_has_delta_sig(*this); };
    };
 
    class crit_in_place_is_binary_patch : public criterium
    {
    public:
    crit_in_place_is_binary_patch() {};
    crit_in_place_is_binary_patch(const crit_in_place_is_binary_patch & ref) = default;
    crit_in_place_is_binary_patch(crit_in_place_is_binary_patch && ref) noexcept = default;
    crit_in_place_is_binary_patch & operator = (const crit_in_place_is_binary_patch & ref) = default;
    crit_in_place_is_binary_patch & operator = (crit_in_place_is_binary_patch && ref) noexcept = default;
    ~crit_in_place_is_binary_patch() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_is_binary_patch(*this); };
    };
 
 
 
    class crit_same_inode_data : public criterium
    {
    public:
    crit_same_inode_data() {};
    crit_same_inode_data(const crit_same_inode_data & ref) = default;
    crit_same_inode_data(crit_same_inode_data && ref) noexcept = default;
    crit_same_inode_data & operator = (const crit_same_inode_data & ref) = default;
    crit_same_inode_data & operator = (crit_same_inode_data && ref) noexcept = default;
    ~crit_same_inode_data() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_same_inode_data(*this); };
    };
 
 
 
    class crit_in_place_EA_present : public criterium
    {
    public:
    crit_in_place_EA_present() {};
    crit_in_place_EA_present(const crit_in_place_EA_present & ref) = default;
    crit_in_place_EA_present(crit_in_place_EA_present && ref) noexcept = default;
    crit_in_place_EA_present & operator = (const crit_in_place_EA_present & ref) = default;
    crit_in_place_EA_present & operator = (crit_in_place_EA_present && ref) noexcept = default;
    ~crit_in_place_EA_present() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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) {};
    crit_in_place_EA_more_recent(const crit_in_place_EA_more_recent & ref) = default;
    crit_in_place_EA_more_recent(crit_in_place_EA_more_recent && ref) noexcept = default;
    crit_in_place_EA_more_recent & operator = (const crit_in_place_EA_more_recent & ref) = default;
    crit_in_place_EA_more_recent & operator = (crit_in_place_EA_more_recent && ref) noexcept = default;
    ~crit_in_place_EA_more_recent() = default;
 
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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) {};
    crit_in_place_EA_more_recent_or_equal_to(const crit_in_place_EA_more_recent_or_equal_to & ref) = default;
    crit_in_place_EA_more_recent_or_equal_to(crit_in_place_EA_more_recent_or_equal_to && ref) noexcept = default;
    crit_in_place_EA_more_recent_or_equal_to & operator = (const crit_in_place_EA_more_recent_or_equal_to & ref) = default;
    crit_in_place_EA_more_recent_or_equal_to & operator = (crit_in_place_EA_more_recent_or_equal_to && ref) noexcept = default;
    ~crit_in_place_EA_more_recent_or_equal_to() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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:
    crit_in_place_more_EA() {};
    crit_in_place_more_EA(const crit_in_place_more_EA & ref) = default;
    crit_in_place_more_EA(crit_in_place_more_EA && ref) noexcept = default;
    crit_in_place_more_EA & operator = (const crit_in_place_more_EA & ref) = default;
    crit_in_place_more_EA & operator = (crit_in_place_more_EA && ref) noexcept = default;
    ~crit_in_place_more_EA() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_more_EA(*this); };
    };
 
 
 
 
 
    class crit_in_place_EA_bigger : public crit_in_place_more_EA
    {
    public:
    crit_in_place_EA_bigger() {};
    crit_in_place_EA_bigger(const crit_in_place_EA_bigger & ref) = default;
    crit_in_place_EA_bigger(crit_in_place_EA_bigger && ref) noexcept = default;
    crit_in_place_EA_bigger & operator = (const crit_in_place_EA_bigger & ref) = default;
    crit_in_place_EA_bigger & operator = (crit_in_place_EA_bigger && ref) noexcept = default;
    ~crit_in_place_EA_bigger() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_bigger(*this); };
    };
 
 
 
 
    class crit_in_place_EA_saved : public criterium
    {
    public:
    crit_in_place_EA_saved() {};
    crit_in_place_EA_saved(const crit_in_place_EA_saved & ref) = default;
    crit_in_place_EA_saved(crit_in_place_EA_saved && ref) noexcept = default;
    crit_in_place_EA_saved & operator = (const crit_in_place_EA_saved & ref) = default;
    crit_in_place_EA_saved & operator = (crit_in_place_EA_saved && ref) noexcept = default;
    ~crit_in_place_EA_saved() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_in_place_EA_saved(*this); };
    };
 
 
 
 
    class crit_same_type : public criterium
    {
    public:
    crit_same_type() {};
    crit_same_type(const crit_same_type & ref) = default;
    crit_same_type(crit_same_type && ref) noexcept = default;
    crit_same_type & operator = (const crit_same_type & ref) = default;
    crit_same_type & operator = (crit_same_type && ref) noexcept = default;
    ~crit_same_type() = default;
 
    virtual bool evaluate(const cat_nomme &first, const cat_nomme &second) const override;
    virtual criterium *clone() const override { 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 == nullptr) throw Ememory("crit_not::crit_not"); };
    crit_not(const crit_not & ref): criterium(ref) { copy_from(ref); };
    crit_not(crit_not && ref) noexcept: criterium(std::move(ref)) { x_crit = nullptr; std::swap(x_crit, ref.x_crit); };
    crit_not & operator = (const crit_not & ref) { destroy(); copy_from(ref); return *this; };
    crit_not & operator = (crit_not && ref) noexcept { criterium::operator = (std::move(ref)); std::swap(x_crit, ref.x_crit); return *this; };
    ~crit_not() { destroy(); };
 
    virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override { return ! x_crit->evaluate(first, second); };
    virtual criterium *clone() const override { 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 != nullptr) { delete x_crit; x_crit = nullptr; } };
    };
 
 
    class crit_and : public criterium
    {
    public:
    crit_and() { clear(); };
    crit_and(const crit_and & ref) : criterium(ref) { copy_from(ref); };
    crit_and(crit_and && ref) = default; // moving the deque<criterium *> while the pointed to object are untouched
    crit_and & operator = (const crit_and & ref) { detruit(); copy_from(ref); return *this; };
    crit_and & operator = (crit_and && ref) noexcept = default; // moving the deque<criterium *> while the pointed to object are untouched
    ~crit_and() { detruit(); };
 
    void add_crit(const criterium & ref);
    void clear() { detruit(); };
 
    void gobe(crit_and & to_be_voided);
 
    virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_and(*this); };
 
    protected:
    std::deque<criterium *> operand;
 
    private:
    void copy_from(const crit_and & ref);
    void detruit();
    };
 
    class crit_or : public crit_and
    {
    public:
    crit_or() { clear(); };
    crit_or(const crit_or & ref) = default;
    crit_or(crit_or && ref) = default;
    crit_or & operator = (const crit_or & ref) = default;
    crit_or & operator = (crit_or && ref) noexcept = default;
    ~crit_or() = default;
 
    virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override;
    virtual criterium *clone() const override { return new (std::nothrow) crit_or(*this); };
 
    };
 
    class crit_invert : public crit_not
    {
    public:
    crit_invert(const criterium & crit) : crit_not(crit) {};
    crit_invert(const crit_invert & ref) = default;
    crit_invert(crit_invert && ref) noexcept = default;
    crit_invert & operator = (const crit_invert & ref) = default;
    crit_invert & operator = (crit_invert && ref) noexcept = default;
    ~crit_invert() = default;
 
    virtual bool evaluate(const cat_nomme & first, const cat_nomme & second) const override { return x_crit->evaluate(second, first); };
    virtual criterium *clone() const override { return new (std::nothrow) crit_invert(*this); };
    };
 
 
} // end of namespace
 
#endif