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 : dar.linux@free.fr 00020 /*********************************************************************/ 00021 // $Id: mask.hpp,v 1.17.2.1 2007/07/22 16:35:00 edrusb Rel $ 00022 // 00023 /*********************************************************************/ 00024 00030 00031 #ifndef MASK_HPP 00032 #define MASK_HPP 00033 00034 #include "../my_config.h" 00035 00036 extern "C" 00037 { 00038 #if HAVE_UNISTD_H 00039 #include <unistd.h> 00040 #endif 00041 00042 #if HAVE_REGEX_H 00043 #include <regex.h> 00044 #endif 00045 } // end extern "C" 00046 00047 #include <string> 00048 #include <vector> 00049 #include "path.hpp" 00050 00051 namespace libdar 00052 { 00053 00056 00058 00061 class mask 00062 { 00063 public : 00064 virtual ~mask() {}; 00065 00067 00071 virtual bool is_covered(const std::string &expression) const = 0; 00072 00075 virtual mask *clone() const = 0; 00076 }; 00077 00078 00080 00082 class bool_mask : public mask 00083 { 00084 public : 00086 00090 bool_mask(bool always) { val = always; }; 00091 00093 bool is_covered(const std::string &) const { return val; }; 00095 mask *clone() const { return new bool_mask(val); }; 00096 00097 private : 00098 bool val; 00099 }; 00100 00101 00103 00104 class simple_mask : public mask 00105 { 00106 public : 00107 00109 00112 simple_mask(const std::string & wilde_card_expression, bool case_sensit); 00114 simple_mask(const simple_mask & m) : mask(m) { copy_from(m); }; 00116 simple_mask & operator = (const simple_mask & m); 00117 00119 bool is_covered(const std::string &expression) const; 00121 mask *clone() const { return new simple_mask(*this); }; 00122 00123 private : 00124 std::string the_mask; 00125 bool case_s; 00126 00127 void copy_from(const simple_mask & m); 00128 }; 00129 00130 00132 00133 class regular_mask : public mask 00134 { 00135 public : 00136 00138 00141 regular_mask(const std::string & wilde_card_expression, 00142 bool x_case_sensit); 00144 regular_mask(const regular_mask & ref); 00146 regular_mask & operator= (const regular_mask & ref); 00147 00149 virtual ~regular_mask() { regfree(&preg); }; 00150 00152 bool is_covered(const std::string & expression) const; 00154 mask *clone() const { return new regular_mask(*this); }; 00155 00156 private : 00157 regex_t preg; 00158 std::string mask_exp; //< used only by the copy constructor 00159 bool case_sensit; //< used only by the copy constructor 00160 00161 void set_preg(const std::string & wilde_card_expression, 00162 bool x_case_sensit); 00163 }; 00164 00165 00167 00170 class not_mask : public mask 00171 { 00172 public : 00174 00178 not_mask(const mask &m) { copy_from(m); }; 00180 not_mask(const not_mask & m) : mask(m) { copy_from(m); }; 00182 not_mask & operator = (const not_mask & m); 00184 ~not_mask() { detruit(); }; 00185 00187 bool is_covered(const std::string &expression) const { return !ref->is_covered(expression); }; 00189 mask *clone() const { return new not_mask(*this); }; 00190 00191 private : 00192 mask *ref; 00193 00194 void copy_from(const not_mask &m); 00195 void copy_from(const mask &m); 00196 void detruit(); 00197 }; 00198 00199 00201 00202 class et_mask : public mask 00203 { 00204 public : 00205 00207 00211 et_mask() {}; 00213 et_mask(const et_mask &m) : mask(m) { copy_from(m); }; 00215 et_mask & operator = (const et_mask &m); 00217 ~et_mask() { detruit(); }; 00218 00219 00221 00225 void add_mask(const mask & toadd); 00226 00228 bool is_covered(const std::string & expression) const; 00230 mask *clone() const { return new et_mask(*this); }; 00231 00233 00236 U_I size() const { return lst.size(); }; 00237 00239 00243 void clear() { detruit(); }; 00244 00245 protected : 00246 std::vector<mask *> lst; 00247 00248 private : 00249 void copy_from(const et_mask & m); 00250 void detruit(); 00251 }; 00252 00253 00255 00260 class ou_mask : public et_mask 00261 { 00262 public : 00264 bool is_covered(const std::string & expression) const; 00266 mask *clone() const { return new ou_mask(*this); }; 00267 }; 00268 00269 00271 00272 class simple_path_mask : public mask 00273 { 00274 public : 00276 00280 simple_path_mask(const std::string &p, bool case_sensit) : chemin(p) { case_s = case_sensit; }; 00281 00283 bool is_covered(const std::string &ch) const; 00285 mask *clone() const { return new simple_path_mask(*this); }; 00286 00287 private : 00288 path chemin; 00289 bool case_s; 00290 }; 00291 00292 00294 00295 class same_path_mask : public mask 00296 { 00297 public : 00299 00302 same_path_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit; }; 00303 00305 bool is_covered(const std::string &ch) const; 00307 mask *clone() const { return new same_path_mask(*this); }; 00308 00309 private : 00310 std::string chemin; 00311 bool case_s; 00312 }; 00313 00314 00316 00317 class exclude_dir_mask : public mask 00318 { 00319 public: 00321 00324 exclude_dir_mask(const std::string &p, bool case_sensit) { chemin = p; case_s = case_sensit;}; 00325 00327 bool is_covered(const std::string &ch) const { return path(ch).is_subdir_of(chemin, case_s); } 00329 mask *clone() const { return new exclude_dir_mask(*this); }; 00330 00331 private: 00332 std::string chemin; 00333 bool case_s; 00334 }; 00335 00337 00338 } // end of namespace 00339 00340 #endif