mask.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 MASK_HPP
#define MASK_HPP

#include "../my_config.h"

extern "C"
{
#if HAVE_UNISTD_H
#include <unistd.h>
#endif

#if HAVE_REGEX_H
#include <regex.h>
#endif
} // end extern "C"

#include <string>
#include <vector>
#include <new>

#include "path.hpp"

namespace libdar
{



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


        virtual bool is_covered(const std::string &expression) const = 0;


        virtual bool is_covered(const path & chemin) const { return is_covered(chemin.display()); };

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



    class bool_mask : public mask
    {
    public :

        bool_mask(bool always) { val = always; };

        bool is_covered(const std::string & expression) const { return val; };
        bool is_covered(const path & chemin) const { return val; };

        mask *clone() const { return new (std::nothrow) bool_mask(val); };

    private :
        bool val;
    };



    class simple_mask : public mask
    {
    public :


        simple_mask(const std::string & wilde_card_expression, bool case_sensit);
        simple_mask(const simple_mask & m) : mask(m) { copy_from(m); };
        const simple_mask & operator = (const simple_mask & m);

        bool is_covered(const std::string &expression) const;

        mask *clone() const { return new (std::nothrow) simple_mask(*this); };

    private :
        std::string the_mask;
        bool case_s;

        void copy_from(const simple_mask & m);
    };



    class regular_mask : public mask
    {
    public :


        regular_mask(const std::string & wilde_card_expression,
                     bool x_case_sensit);
        regular_mask(const regular_mask & ref);
        regular_mask & operator= (const regular_mask & ref);

        virtual ~regular_mask() { regfree(&preg); };

        bool is_covered(const std::string & expression) const;

        mask *clone() const { return new (std::nothrow) regular_mask(*this); };

    private :
        regex_t preg;
        std::string mask_exp; //< used only by the copy constructor
        bool case_sensit;     //< used only by the copy constructor

        void set_preg(const std::string & wilde_card_expression,
                      bool x_case_sensit);
    };



    class not_mask : public mask
    {
    public :

        not_mask(const mask &m) { copy_from(m); };
        not_mask(const not_mask & m) : mask(m) { copy_from(m); };
        const not_mask & operator = (const not_mask & m);
        ~not_mask() { detruit(); };

        bool is_covered(const std::string &expression) const { return !ref->is_covered(expression); };
        bool is_covered(const path & chemin) const { return !ref->is_covered(chemin); };

        mask *clone() const { return new (std::nothrow) not_mask(*this); };

    private :
        mask *ref;

        void copy_from(const not_mask &m);
        void copy_from(const mask &m);
        void detruit();
    };



    class et_mask : public mask
    {
    public :


        et_mask() {};
        et_mask(const et_mask &m) : mask(m) { copy_from(m); };
        const et_mask & operator = (const et_mask &m);
        ~et_mask() { detruit(); };



        void add_mask(const mask & toadd);

        bool is_covered(const std::string & expression) const { return t_is_covered(expression); };
        bool is_covered(const path & chemin) const { return t_is_covered(chemin); };

        mask *clone() const { return new (std::nothrow) et_mask(*this); };


        U_I size() const { return lst.size(); };


        void clear() { detruit(); };

    protected :
        std::vector<mask *> lst;

    private :
        void copy_from(const et_mask & m);
        void detruit();

        template<class T> bool t_is_covered(const T & expression) const
        {
            std::vector<mask *>::const_iterator it = lst.begin();

            if(lst.empty())
                throw Erange("et_mask::is_covered", dar_gettext("No mask in the list of mask to operate on"));

            while(it != lst.end() && (*it)->is_covered(expression))
                ++it;

            return it == lst.end();
        }

    };



    class ou_mask : public et_mask
    {
    public:
        bool is_covered(const std::string & expression) const { return t_is_covered(expression); };
        bool is_covered(const path & chemin) const { return t_is_covered(chemin); }
;
        mask *clone() const { return new (std::nothrow) ou_mask(*this); };

    private:
        template<class T> bool t_is_covered(const T & expression) const
        {
            std::vector<mask *>::const_iterator it = lst.begin();

            if(lst.empty())
                throw Erange("et_mask::is_covered", dar_gettext("No mask to operate on in the list of mask"));

            while(it != lst.end() && ! (*it)->is_covered(expression))
                it++;

            return it != lst.end();
        }

    };



    class simple_path_mask : public mask
    {
    public :

        simple_path_mask(const path &p, bool case_sensit) : chemin(p) { case_s = case_sensit; };

        bool is_covered(const std::string & expression) const { throw SRC_BUG; };
        bool is_covered(const path & chemin) const;

        mask *clone() const { return new (std::nothrow) simple_path_mask(*this); };

    private :
        path chemin;
        bool case_s;
    };



    class same_path_mask : public mask
    {
    public :

        same_path_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit; };

        bool is_covered(const std::string &chemin) const;

        mask *clone() const { return new (std::nothrow) same_path_mask(*this); };

    private :
        std::string chemin;
        bool case_s;
    };



    class exclude_dir_mask : public mask
    {
    public:

        exclude_dir_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit;};

        bool is_covered(const std::string &expression) const { throw SRC_BUG; }
        bool is_covered(const path &chemin) const { return chemin.is_subdir_of(chemin, case_s); };

        mask *clone() const { return new (std::nothrow) exclude_dir_mask(*this); };

    private:
        std::string chemin;
        bool case_s;
    };


} // end of namespace

#endif