Disk ARchive  2.5.2
Full featured and portable backup and archiving tool
mask.hpp
Go to the documentation of this file.
00001 /*********************************************************************/
00002 // dar - disk archive - a backup/restoration program
00003 // Copyright (C) 2002-2052 Denis Corbin
00004 //
00005 // This program is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU General Public License
00007 // as published by the Free Software Foundation; either version 2
00008 // of the License, or (at your option) any later version.
00009 //
00010 // This program is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU General Public License
00016 // along with this program; if not, write to the Free Software
00017 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00018 //
00019 // to contact the author : http://dar.linux.free.fr/email.html
00020 /*********************************************************************/
00021 
00028 
00029 #ifndef MASK_HPP
00030 #define MASK_HPP
00031 
00032 #include "../my_config.h"
00033 
00034 extern "C"
00035 {
00036 #if HAVE_UNISTD_H
00037 #include <unistd.h>
00038 #endif
00039 
00040 #if HAVE_REGEX_H
00041 #include <regex.h>
00042 #endif
00043 } // end extern "C"
00044 
00045 #include <string>
00046 #include <vector>
00047 
00048 #include "path.hpp"
00049 #include "on_pool.hpp"
00050 
00051 namespace libdar
00052 {
00053 
00056 
00058 
00061     class mask : public on_pool
00062     {
00063     public :
00064         virtual ~mask() {};
00065 
00067 
00071         virtual bool is_covered(const std::string &expression) const = 0;
00072 
00074 
00079     virtual bool is_covered(const path & chemin) const { return is_covered(chemin.display()); };
00080 
00083         virtual mask *clone() const = 0;
00084     };
00085 
00086 
00088 
00090     class bool_mask : public mask
00091     {
00092     public :
00094 
00098         bool_mask(bool always) { val = always; };
00099 
00101         bool is_covered(const std::string & expression) const { return val; };
00102         bool is_covered(const path & chemin) const { return val; };
00103 
00105         mask *clone() const { return new (get_pool()) bool_mask(val); };
00106 
00107     private :
00108         bool val;
00109     };
00110 
00111 
00113 
00114     class simple_mask : public mask
00115     {
00116     public :
00117 
00119 
00122         simple_mask(const std::string & wilde_card_expression, bool case_sensit);
00124         simple_mask(const simple_mask & m) : mask(m) { copy_from(m); };
00126         const simple_mask & operator = (const simple_mask & m);
00127 
00129         bool is_covered(const std::string &expression) const;
00130 
00132         mask *clone() const { return new (get_pool()) simple_mask(*this); };
00133 
00134     private :
00135         std::string the_mask;
00136     bool case_s;
00137 
00138         void copy_from(const simple_mask & m);
00139     };
00140 
00141 
00143 
00144     class regular_mask : public mask
00145     {
00146     public :
00147 
00149 
00152         regular_mask(const std::string & wilde_card_expression,
00153              bool x_case_sensit);
00155     regular_mask(const regular_mask & ref);
00157     regular_mask & operator= (const regular_mask & ref);
00158 
00160         virtual ~regular_mask() { regfree(&preg); };
00161 
00163         bool is_covered(const std::string & expression) const;
00164 
00166         mask *clone() const { return new (get_pool()) regular_mask(*this); };
00167 
00168     private :
00169         regex_t preg;
00170     std::string mask_exp; //< used only by the copy constructor
00171     bool case_sensit;     //< used only by the copy constructor
00172 
00173     void set_preg(const std::string & wilde_card_expression,
00174               bool x_case_sensit);
00175     };
00176 
00177 
00179 
00182     class not_mask : public mask
00183     {
00184     public :
00186 
00190         not_mask(const mask &m) { copy_from(m); };
00192         not_mask(const not_mask & m) : mask(m) { copy_from(m); };
00194         const not_mask & operator = (const not_mask & m);
00196         ~not_mask() { detruit(); };
00197 
00199         bool is_covered(const std::string &expression) const { return !ref->is_covered(expression); };
00200         bool is_covered(const path & chemin) const { return !ref->is_covered(chemin); };
00201 
00203         mask *clone() const { return new (get_pool()) not_mask(*this); };
00204 
00205     private :
00206         mask *ref;
00207 
00208         void copy_from(const not_mask &m);
00209         void copy_from(const mask &m);
00210         void detruit();
00211     };
00212 
00213 
00215 
00216     class et_mask : public mask
00217     {
00218     public :
00219 
00221 
00225         et_mask() {};
00227         et_mask(const et_mask &m) : mask(m) { copy_from(m); };
00229         const et_mask & operator = (const et_mask &m);
00231         ~et_mask() { detruit(); };
00232 
00233 
00235 
00239         void add_mask(const mask & toadd);
00240 
00242         bool is_covered(const std::string & expression) const { return t_is_covered(expression); };
00243         bool is_covered(const path & chemin) const { return t_is_covered(chemin); };
00244 
00246         mask *clone() const { return new (get_pool()) et_mask(*this); };
00247 
00249 
00252         U_I size() const { return lst.size(); };
00253 
00255 
00259     void clear() { detruit(); };
00260 
00261     protected :
00262         std::vector<mask *> lst;
00263 
00264     private :
00265         void copy_from(const et_mask & m);
00266         void detruit();
00267 
00268     template<class T> bool t_is_covered(const T & expression) const
00269     {
00270         std::vector<mask *>::const_iterator it = lst.begin();
00271 
00272         if(lst.empty())
00273         throw Erange("et_mask::is_covered", dar_gettext("No mask in the list of mask to operate on"));
00274 
00275         while(it != lst.end() && (*it)->is_covered(expression))
00276         ++it;
00277 
00278         return it == lst.end();
00279     }
00280 
00281     };
00282 
00283 
00285 
00290     class ou_mask : public et_mask
00291     {
00292     public:
00294         bool is_covered(const std::string & expression) const { return t_is_covered(expression); };
00295         bool is_covered(const path & chemin) const { return t_is_covered(chemin); }
00296     ;
00298         mask *clone() const { return new (get_pool()) ou_mask(*this); };
00299 
00300     private:
00301     template<class T> bool t_is_covered(const T & expression) const
00302     {
00303         std::vector<mask *>::const_iterator it = lst.begin();
00304 
00305         if(lst.empty())
00306         throw Erange("et_mask::is_covered", dar_gettext("No mask to operate on in the list of mask"));
00307 
00308         while(it != lst.end() && ! (*it)->is_covered(expression))
00309         it++;
00310 
00311         return it != lst.end();
00312     }
00313 
00314     };
00315 
00316 
00318 
00319     class simple_path_mask : public mask
00320     {
00321     public :
00323 
00327         simple_path_mask(const path &p, bool case_sensit) : chemin(p) { case_s = case_sensit; };
00328 
00330         bool is_covered(const std::string & expression) const { throw SRC_BUG; };
00331         bool is_covered(const path & chemin) const;
00332 
00334         mask *clone() const { return new (get_pool()) simple_path_mask(*this); };
00335 
00336     private :
00337         path chemin;
00338     bool case_s;
00339     };
00340 
00341 
00343 
00344     class same_path_mask : public mask
00345     {
00346     public :
00348 
00351         same_path_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit; };
00352 
00354         bool is_covered(const std::string &chemin) const;
00355 
00357         mask *clone() const { return new (get_pool()) same_path_mask(*this); };
00358 
00359     private :
00360         std::string chemin;
00361     bool case_s;
00362     };
00363 
00364 
00366 
00367     class exclude_dir_mask : public mask
00368     {
00369     public:
00371 
00374     exclude_dir_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit;};
00375 
00377     bool is_covered(const std::string &expression) const { throw SRC_BUG; }
00378     bool is_covered(const path &chemin) const { return chemin.is_subdir_of(chemin, case_s); };
00379 
00381     mask *clone() const { return new (get_pool()) exclude_dir_mask(*this); };
00382 
00383     private:
00384     std::string chemin;
00385     bool case_s;
00386     };
00387 
00389 
00390 } // end of namespace
00391 
00392 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines