Milena (Olena)
User documentation 2.0a Id
|
00001 // Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (LRDE) 00002 // 00003 // This file is part of Olena. 00004 // 00005 // Olena is free software: you can redistribute it and/or modify it under 00006 // the terms of the GNU General Public License as published by the Free 00007 // Software Foundation, version 2 of the License. 00008 // 00009 // Olena is distributed in the hope that it will be useful, 00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00012 // General Public License for more details. 00013 // 00014 // You should have received a copy of the GNU General Public License 00015 // along with Olena. If not, see <http://www.gnu.org/licenses/>. 00016 // 00017 // As a special exception, you may use this file as part of a free 00018 // software project without restriction. Specifically, if other files 00019 // instantiate templates or use macros or inline functions from this 00020 // file, or you compile this file and link it with other files to produce 00021 // an executable, this file does not by itself cause the resulting 00022 // executable to be covered by the GNU General Public License. This 00023 // exception does not however invalidate any other reasons why the 00024 // executable file might be covered by the GNU General Public License. 00025 00026 #ifndef MLN_TOPO_N_FACES_SET_HH 00027 # define MLN_TOPO_N_FACES_SET_HH 00028 00031 00032 #include <vector> 00033 00034 #include <mln/core/contract.hh> 00035 #include <mln/topo/algebraic_n_face.hh> 00036 00037 // FIXME: Rename as algebraic_n_faces_set? 00038 00039 00040 namespace mln 00041 { 00042 00043 namespace topo 00044 { 00045 00046 // Forward declaration. 00047 template <unsigned D> class complex; 00048 00049 00050 /*------------------------------------. 00051 | Set of (algebraic) n-face handles. | 00052 `------------------------------------*/ 00053 00055 template <unsigned N, unsigned D> 00056 class n_faces_set 00057 { 00058 public: 00060 void add(const algebraic_n_face<N, D>& f); 00061 00067 void reserve(size_t n); 00068 00070 typedef std::vector< algebraic_n_face<N, D> > faces_type; 00071 00076 const faces_type& faces() const; 00078 00079 private: 00080 friend class complex<D>; 00081 00083 faces_type faces_; 00084 }; 00085 00086 00087 /*-----------------------. 00088 | Construction helpers. | 00089 `-----------------------*/ 00090 00091 /* FIXME: We can probably reduce the number of operators, given 00092 the fact that ``a - b'' is equivalent to ``a + (-b)''. */ 00093 00096 template <unsigned N, unsigned D> 00097 n_faces_set<N, D> 00098 operator+(const algebraic_n_face<N, D>& f1, 00099 const algebraic_n_face<N, D>& f2); 00100 00101 template <unsigned N, unsigned D> 00102 n_faces_set<N, D> 00103 operator+(const algebraic_n_face<N, D>& f1, const n_face<N, D>& f2); 00104 00105 template <unsigned N, unsigned D> 00106 n_faces_set<N, D> 00107 operator+(const n_face<N, D>& f1, const algebraic_n_face<N, D>& f2); 00108 00109 template <unsigned N, unsigned D> 00110 n_faces_set<N, D> 00111 operator+(const n_face<N, D>& f1, const n_face<N, D>& f2); 00112 00113 00114 template <unsigned N, unsigned D> 00115 n_faces_set<N, D> 00116 operator+(const n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f); 00117 00118 template <unsigned N, unsigned D> 00119 n_faces_set<N, D> 00120 operator+(const n_faces_set<N, D>& fs, const n_face<N, D>& f); 00121 00122 template <unsigned N, unsigned D> 00123 n_faces_set<N, D>& 00124 operator+=(n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f); 00126 00129 template <unsigned N, unsigned D> 00130 n_faces_set<N, D> 00131 operator-(const algebraic_n_face<N, D>& f1, 00132 const algebraic_n_face<N, D>& f2); 00133 00134 template <unsigned N, unsigned D> 00135 n_faces_set<N, D> 00136 operator-(const algebraic_n_face<N, D>& f1, const n_face<N, D>& f2); 00137 00138 template <unsigned N, unsigned D> 00139 n_faces_set<N, D> 00140 operator-(const n_face<N, D>& f1, const algebraic_n_face<N, D>& f2); 00141 00142 template <unsigned N, unsigned D> 00143 n_faces_set<N, D> 00144 operator-(const n_face<N, D>& f1, const n_face<N, D>& f2); 00145 00146 00147 template <unsigned N, unsigned D> 00148 n_faces_set<N, D> 00149 operator-(const n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f); 00150 00151 template <unsigned N, unsigned D> 00152 n_faces_set<N, D> 00153 operator-(const n_faces_set<N, D>& fs, const n_face<N, D>& f); 00154 00155 template <unsigned N, unsigned D> 00156 n_faces_set<N, D>& 00157 operator-=(n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f); 00159 00160 00161 00162 # ifndef MLN_INCLUDE_ONLY 00163 00164 /*------------------------------------. 00165 | Set of (algebraic) n-face handles. | 00166 `------------------------------------*/ 00167 00168 template <unsigned N, unsigned D> 00169 inline 00170 void 00171 n_faces_set<N, D>::add(const algebraic_n_face<N, D>& f) 00172 { 00173 // Check consistency. 00174 if (!faces_.empty()) 00175 mln_precondition(faces_.front().cplx() == f.cplx()); 00176 faces_.push_back(f); 00177 } 00178 00179 template <unsigned N, unsigned D> 00180 inline 00181 void 00182 n_faces_set<N, D>::reserve(size_t n) 00183 { 00184 faces_.reserve(n); 00185 } 00186 00187 template <unsigned N, unsigned D> 00188 inline 00189 const std::vector< algebraic_n_face<N, D> >& 00190 n_faces_set<N, D>::faces() const 00191 { 00192 return faces_; 00193 } 00194 00195 /*-----------------------. 00196 | Construction helpers. | 00197 `-----------------------*/ 00198 00199 // ---------- // 00200 // Addition. // 00201 // ---------- // 00202 00203 template <unsigned N, unsigned D> 00204 inline 00205 n_faces_set<N, D> 00206 operator+(const algebraic_n_face<N, D>& f1, 00207 const algebraic_n_face<N, D>& f2) 00208 { 00209 n_faces_set<N, D> fs; 00210 fs.add(f1); 00211 fs.add(f2); 00212 return fs; 00213 } 00214 00215 template <unsigned N, unsigned D> 00216 inline 00217 n_faces_set<N, D> 00218 operator+(const algebraic_n_face<N, D>& f1, const n_face<N, D>& f2) 00219 { 00220 n_faces_set<N, D> fs; 00221 fs.add(f1); 00222 fs.add(make_algebraic_n_face(f2, true)); 00223 return fs; 00224 } 00225 00226 template <unsigned N, unsigned D> 00227 inline 00228 n_faces_set<N, D> 00229 operator+(const n_face<N, D>& f1, const algebraic_n_face<N, D>& f2) 00230 { 00231 n_faces_set<N, D> fs; 00232 fs.add(make_algebraic_n_face(f1, true)); 00233 fs.add(f2); 00234 return fs; 00235 } 00236 00237 template <unsigned N, unsigned D> 00238 inline 00239 n_faces_set<N, D> 00240 operator+(const n_face<N, D>& f1, const n_face<N, D>& f2) 00241 { 00242 n_faces_set<N, D> fs; 00243 fs.add(make_algebraic_n_face(f1, true)); 00244 fs.add(make_algebraic_n_face(f2, true)); 00245 return fs; 00246 } 00247 00248 00249 template <unsigned N, unsigned D> 00250 inline 00251 n_faces_set<N, D> 00252 operator+(const n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f) 00253 { 00254 n_faces_set<N, D> fs2(fs); 00255 fs2.add(f); 00256 return fs2; 00257 } 00258 00259 template <unsigned N, unsigned D> 00260 inline 00261 n_faces_set<N, D> 00262 operator+(const n_faces_set<N, D>& fs, const n_face<N, D>& f) 00263 { 00264 n_faces_set<N, D> fs2(fs); 00265 fs2.add(make_algebraic_n_face(f, true)); 00266 return fs2; 00267 } 00268 00269 template <unsigned N, unsigned D> 00270 n_faces_set<N, D>& 00271 operator+=(n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f) 00272 { 00273 fs.add(f); 00274 return fs; 00275 } 00276 00277 // ------------- // 00278 // Subtraction. // 00279 // ------------- // 00280 00281 template <unsigned N, unsigned D> 00282 inline 00283 n_faces_set<N, D> 00284 operator-(const algebraic_n_face<N, D>& f1, 00285 const algebraic_n_face<N, D>& f2) 00286 { 00287 n_faces_set<N, D> fs; 00288 fs.add(f1); 00289 fs.add(-f2); 00290 return fs; 00291 } 00292 00293 template <unsigned N, unsigned D> 00294 inline 00295 n_faces_set<N, D> 00296 operator-(const algebraic_n_face<N, D>& f1, const n_face<N, D>& f2) 00297 { 00298 n_faces_set<N, D> fs; 00299 fs.add(f1); 00300 fs.add(make_algebraic_n_face(f2, false)); 00301 return fs; 00302 } 00303 00304 template <unsigned N, unsigned D> 00305 inline 00306 n_faces_set<N, D> 00307 operator-(const n_face<N, D>& f1, const algebraic_n_face<N, D>& f2) 00308 { 00309 n_faces_set<N, D> fs; 00310 fs.add(make_algebraic_n_face(f1, true)); 00311 fs.add(-f2); 00312 return fs; 00313 } 00314 00315 template <unsigned N, unsigned D> 00316 inline 00317 n_faces_set<N, D> 00318 operator-(const n_face<N, D>& f1, const n_face<N, D>& f2) 00319 { 00320 n_faces_set<N, D> fs; 00321 fs.add(make_algebraic_n_face(f1, true)); 00322 fs.add(make_algebraic_n_face(f2, false)); 00323 return fs; 00324 } 00325 00326 00327 template <unsigned N, unsigned D> 00328 inline 00329 n_faces_set<N, D> 00330 operator-(const n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f) 00331 { 00332 n_faces_set<N, D> fs2(fs); 00333 fs2.add(-f); 00334 return fs2; 00335 } 00336 00337 template <unsigned N, unsigned D> 00338 inline 00339 n_faces_set<N, D> 00340 operator-(const n_faces_set<N, D>& fs, const n_face<N, D>& f) 00341 { 00342 n_faces_set<N, D> fs2(fs); 00343 fs2.add(make_algebraic_n_face(f, false)); 00344 return fs2; 00345 } 00346 00347 template <unsigned N, unsigned D> 00348 n_faces_set<N, D>& 00349 operator-=(n_faces_set<N, D>& fs, const algebraic_n_face<N, D>& f) 00350 { 00351 fs.add(-f); 00352 return fs; 00353 } 00354 00355 # endif // ! MLN_INCLUDE_ONLY 00356 00357 } // end of namespace mln::topo 00358 00359 } // end of namespace mln 00360 00361 #endif // ! MLN_TOPO_N_FACES_SET_HH