Moka gmapkernel: src/lib-gmapkernel/g-map/dart.icc Source File

00001 /*
00002  * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
00003  * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
00004  *               http://www.sic.sp2mi.univ-poitiers.fr/
00005  * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
00006  *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
00007  *
00008  * This file is part of lib-gmapkernel
00009  *
00010  * This program is free software: you can redistribute it and/or modify
00011  * it under the terms of the GNU Lesser General Public License as published by
00012  * the Free Software Foundation, either version 3 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public License
00021  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00022  */
00023 
00024 //******************************************************************************
00025 #include "attribute.hh"
00026 #include "embedding.hh"
00027 
00028 #include <cassert>
00029 //******************************************************************************
00030 namespace GMap3d
00031 {
00032 //******************************************************************************
00033 // Constructeurs
00034 // On initialise pas les champs FMarks et FUsedOrbits car tout les bits sont
00035 // initialisées à faux par défaut (constructeur de bitset).
00036 INLINE
00037 CDart::CDart() :
00038   FFirstEmbedding(NULL),
00039   FPrev          (NULL),
00040   FNext          (NULL)
00041 {
00042   FAlpha[0] = this;
00043   FAlpha[1] = this;
00044   FAlpha[2] = this;
00045   FAlpha[3] = this;
00046 }
00047 //******************************************************************************
00048 INLINE
00049 CDart::CDart(const CDart& ADart) :
00050   FFirstEmbedding(NULL),
00051   FMarks         (ADart.FMarks),
00052   FUsedOrbits    (ADart.FUsedOrbits),
00053   FPrev          (NULL),
00054   FNext          (NULL)
00055 {
00056   FAlpha[0] = this;
00057   FAlpha[1] = this;
00058   FAlpha[2] = this;
00059   FAlpha[3] = this;
00060 }
00061 //******************************************************************************
00062 INLINE
00063 CDart::CDart(const std::bitset<NB_MARKS>& AMarks) :
00064   FFirstEmbedding(NULL),
00065   FMarks         (AMarks),
00066   FPrev          (NULL),
00067   FNext          (NULL)
00068 {
00069   FAlpha[0] = this;
00070   FAlpha[1] = this;
00071   FAlpha[2] = this;
00072   FAlpha[3] = this;
00073 }
00074 //******************************************************************************
00075 // Destructeur
00076 // Attention, si le brin n'a pas été préalablement décousu alors ses brins 
00077 // voisins pointent désormais vers une adresse invalide.
00078 INLINE
00079 CDart::~CDart()
00080 {
00081   CEmbedding* E = FFirstEmbedding;
00082 
00083   // Destruction de tout les embedding de la liste
00084   while(E != NULL)
00085     {
00086       CEmbedding* tmp = E;
00087       E = E->getNext();
00088       delete tmp;
00089     }
00090 }
00091 //******************************************************************************
00092 INLINE
00093 CEmbedding* CDart::getFirstEmbedding() const
00094 {
00095   return FFirstEmbedding;
00096 }
00097 //******************************************************************************
00098 INLINE
00099 void CDart::setFirstEmbedding(CEmbedding* AEmbedding)
00100 {
00101   FFirstEmbedding = AEmbedding;
00102 }
00103 //******************************************************************************
00104 INLINE
00105 CDart* CDart::getAlpha0() const
00106 {
00107   return FAlpha[0];
00108 }
00109 //******************************************************************************
00110 INLINE
00111 CDart* CDart::getAlpha1() const
00112 {
00113   return FAlpha[1];
00114 }
00115 //******************************************************************************
00116 INLINE
00117 CDart* CDart::getAlpha2() const
00118 {
00119   return FAlpha[2];
00120 }
00121 //******************************************************************************
00122 INLINE
00123 CDart* CDart::getAlpha3() const
00124 {
00125   return FAlpha[3];
00126 }
00127 //******************************************************************************
00128 INLINE
00129 CDart* CDart::getAlpha(int ADimension) const
00130 {
00131   assert(0<=ADimension && ADimension<=3);
00132   
00133   return FAlpha[ADimension];
00134 }
00135 //******************************************************************************
00136 INLINE
00137 void CDart::setAlpha0(CDart* ADart)
00138 {
00139   assert(ADart != NULL);
00140   
00141   FAlpha[0] = ADart;
00142 }
00143 //******************************************************************************
00144 INLINE
00145 void CDart::setAlpha1(CDart* ADart)
00146 {
00147   assert(ADart != NULL);
00148   
00149   FAlpha[1] = ADart;
00150 }
00151 //******************************************************************************
00152 INLINE
00153 void CDart::setAlpha2(CDart* ADart)
00154 {
00155   assert(ADart != NULL);
00156   
00157   FAlpha[2] = ADart;
00158 }
00159 //******************************************************************************
00160 INLINE
00161 void CDart::setAlpha3(CDart* ADart)
00162 {
00163   assert(ADart != NULL);
00164   
00165   FAlpha[3] = ADart;
00166 }
00167 //******************************************************************************
00168 INLINE
00169 void CDart::setAlpha(CDart* ADart, int ADimension)
00170 {
00171   assert(ADart != NULL);
00172   assert(0<=ADimension && ADimension<=3);
00173   
00174   FAlpha[ADimension] = ADart;
00175 }
00176 //******************************************************************************
00177 INLINE
00178 bool CDart::isFree0() const
00179 {
00180   return FAlpha[0] == this;
00181 }
00182 //******************************************************************************
00183 INLINE
00184 bool CDart::isFree1() const
00185 {
00186   return FAlpha[1] == this;
00187 }
00188 //******************************************************************************
00189 INLINE
00190 bool CDart::isFree2() const
00191 {
00192   return FAlpha[2] == this;
00193 }
00194 //******************************************************************************
00195 INLINE
00196 bool CDart::isFree3() const
00197 {
00198   return FAlpha[3] == this;
00199 }
00200 //******************************************************************************
00201 INLINE
00202 bool CDart::isFree(int ADimension) const
00203 {
00204   assert(0<=ADimension && ADimension<=3);
00205 
00206   return FAlpha[ADimension] == this;
00207 }
00208 //******************************************************************************
00209 INLINE
00210 void CDart::setFree0()
00211 {
00212   FAlpha[0] = this;
00213 }
00214 //******************************************************************************
00215 INLINE
00216 void CDart::setFree1()
00217 {
00218   FAlpha[1] = this;
00219 }
00220 //******************************************************************************
00221 INLINE
00222 void CDart::setFree2()
00223 {
00224   FAlpha[2]=this;
00225 }
00226 //******************************************************************************
00227 INLINE
00228 void CDart::setFree3()
00229 {
00230   FAlpha[3] = this;
00231 }
00232 //******************************************************************************
00233 INLINE
00234 void CDart::setFree(int ADimension)
00235 {
00236   assert(0<=ADimension && ADimension<=3);
00237 
00238   FAlpha[ADimension] = this;
00239 }
00240 //******************************************************************************
00241 INLINE
00242 void* CDart::getDirectInfo(int ADirectIndex) const
00243 {
00244   assert(0<=ADirectIndex && ADirectIndex<NB_DIRECT_INFO);
00245 
00246   return FDirectInfo[ADirectIndex];
00247 }
00248 //******************************************************************************
00249 INLINE
00250 void CDart::setDirectInfo(int ADirectIndex, void* AValue)
00251 {
00252   assert(0<=ADirectIndex && ADirectIndex<NB_DIRECT_INFO);
00253 
00254   FDirectInfo[ADirectIndex] = AValue;
00255 }
00256 //******************************************************************************
00257 INLINE
00258 bool CDart::getMark(int AMarkNumber) const
00259 {
00260   assert(0<=AMarkNumber && AMarkNumber<NB_MARKS);
00261 
00262   return FMarks[AMarkNumber];
00263 }
00264 //******************************************************************************
00265 INLINE
00266 void CDart::setMark(int AMarkNumber, bool AValue)
00267 {
00268   assert(0<=AMarkNumber && AMarkNumber<NB_MARKS);
00269 
00270   FMarks.set(AMarkNumber, AValue);
00271 }
00272 //******************************************************************************
00273 INLINE
00274 std::bitset<NB_MARKS> CDart::getMarks() const
00275 {
00276   return FMarks;
00277 }
00278 //******************************************************************************
00279 INLINE
00280 void CDart::setMarks(const std::bitset<NB_MARKS>& AMarks)
00281 {
00282   this->FMarks = AMarks;
00283 }
00284 //******************************************************************************
00285 INLINE
00286 void CDart::setOrbitUsed(TOrbit AOrbit)
00287 {
00288   assert(ORBIT_SELF<=AOrbit && AOrbit<=ORBIT_0123);
00289 
00290   FUsedOrbits.set(static_cast<int>(AOrbit), true);
00291 }
00292 //******************************************************************************
00293 INLINE
00294 void CDart::unsetOrbitUsed(TOrbit AOrbit)
00295 {
00296   assert(ORBIT_SELF<=AOrbit && AOrbit<=ORBIT_0123);
00297 
00298   FUsedOrbits.set(static_cast<int>(AOrbit), false);
00299 }
00300 //******************************************************************************
00301 INLINE
00302 bool CDart::isOrbitUsed(TOrbit AOrbit) const
00303 {
00304   assert(ORBIT_SELF<=AOrbit && AOrbit<=ORBIT_0123);
00305 
00306   return FUsedOrbits[static_cast<int>(AOrbit)];
00307 }
00308 //******************************************************************************
00309 INLINE
00310 CDart* CDart::getPrev() const
00311 {
00312   return FPrev;
00313 }
00314 //******************************************************************************
00315 INLINE
00316 void CDart::setPrev(CDart* ADart)
00317 {
00318   FPrev = ADart;
00319 }
00320 //******************************************************************************
00321 INLINE
00322 CDart* CDart::getNext() const
00323 {
00324   return FNext;
00325 }
00326 //******************************************************************************
00327 INLINE
00328 void CDart::setNext(CDart* ADart)
00329 {
00330   FNext = ADart;
00331 }
00332 //******************************************************************************
00333 INLINE
00334 CEmbedding* CDart::getEmbedding(TOrbit AOrbit) const
00335 {
00336   if (isOrbitUsed(AOrbit))
00337     {
00338       CEmbedding* E = getFirstEmbedding();
00339 
00340       while (E != NULL)
00341         {
00342           if (E->getOrbit() == AOrbit)
00343             return E;
00344 
00345           E = E->getNext();
00346         }
00347     }
00348 
00349   return NULL;
00350 }
00351 //******************************************************************************
00352 INLINE
00353 void CDart::addEmbedding(CEmbedding* AEmbedding)
00354 {
00355   assert(AEmbedding != NULL);
00356   assert(AEmbedding->getPrev() == NULL && AEmbedding->getNext() == NULL);
00357   assert(getEmbedding(AEmbedding->getOrbit()) == NULL);
00358 
00359   setOrbitUsed(AEmbedding->getOrbit());
00360 
00361   if (getFirstEmbedding() != NULL)
00362     {
00363       // Insertion dans la liste :
00364       getFirstEmbedding()->setPrev(AEmbedding);
00365       AEmbedding->setNext(getFirstEmbedding());
00366     }
00367 
00368   setFirstEmbedding(AEmbedding);
00369 }
00370 //******************************************************************************
00371 INLINE
00372 CEmbedding* CDart::removeEmbedding(CEmbedding* AEmbedding)
00373 {
00374   assert(AEmbedding != NULL);
00375 
00376   if (getFirstEmbedding() == AEmbedding)
00377     {
00378       assert(AEmbedding->getPrev() == NULL);
00379       setFirstEmbedding(AEmbedding->getNext());
00380     }
00381   else
00382     {
00383       assert(AEmbedding->getPrev() != NULL);
00384       AEmbedding->getPrev()->setNext(AEmbedding->getNext());
00385     }
00386 
00387   if (AEmbedding->getNext() != NULL)
00388     AEmbedding->getNext()->setPrev(AEmbedding->getPrev());
00389 
00390   return AEmbedding;
00391 }
00392 //******************************************************************************
00393 INLINE
00394 CEmbedding* CDart::removeEmbedding(TOrbit AOrbit)
00395 {
00396   CEmbedding* E = getEmbedding(AOrbit);
00397   
00398   if (E == NULL)
00399     return NULL;
00400   
00401   unsetOrbitUsed(AOrbit);
00402   return removeEmbedding(E);
00403 }
00404 //******************************************************************************
00405 INLINE
00406 void CDart::deleteEmbedding(CEmbedding* AEmbedding)
00407 {
00408   assert(AEmbedding != NULL);
00409 
00410   delete removeEmbedding(AEmbedding);
00411 }
00412 //******************************************************************************
00413 INLINE
00414 void CDart::deleteEmbedding(TOrbit AOrbit)
00415 {
00416   delete removeEmbedding(AOrbit); // car delete NULL marche et ne fait rien
00417 }
00418 //******************************************************************************
00419 INLINE
00420 CAttribute* CDart::getAttribute(TOrbit AOrbit, TAttributeId AAttribType) const
00421 {
00422   CEmbedding* E = getEmbedding(AOrbit);
00423   
00424   if (E == NULL)
00425     return NULL;
00426   
00427   return E->getAttribute(AAttribType);
00428 }
00429 //******************************************************************************
00430 INLINE
00431 void CDart::addAttribute(TOrbit AOrbit, CAttribute* AAttribute)
00432 {
00433   assert(AAttribute != NULL);
00434 
00435   CEmbedding* E = getEmbedding(AOrbit);
00436 
00437   if (E == NULL)
00438     { // Le brin n'a pas d'embedding pour cette orbite et donc on en créé un.
00439       E = new CEmbedding(AOrbit);
00440       addEmbedding(E);
00441     }
00442 
00443   E->addAttribute(AAttribute);
00444 }
00445 //******************************************************************************
00446 INLINE
00447 void CDart::mergeEmbedding(CEmbedding* AEmbedding)
00448 {
00449   assert(AEmbedding != NULL);
00450 
00451   CEmbedding* E = getEmbedding(AEmbedding->getOrbit());
00452 
00453   if (E == NULL)
00454     { // Le brin n'a pas d'embedding pour cette orbite et donc on en créé un
00455       // et on prend tout les attributs de AEmbedding sans test.
00456       E = new CEmbedding(AEmbedding->getOrbit());
00457       addEmbedding(E);
00458       E->setFirstAttribute(AEmbedding->getFirstAttribute());
00459       AEmbedding->setFirstAttribute(NULL);
00460     }
00461   else // Ici on va seulement prendre les attributs de AEmbedding qu'on n'a pas.
00462     E->mergeAttribute(AEmbedding);
00463 }
00464 //******************************************************************************
00465 INLINE
00466 CAttribute* CDart::removeAttribute(TOrbit AOrbit, TAttributeId AAttribType)
00467 {
00468   CAttribute* A = NULL;
00469   CEmbedding* E = getEmbedding(AOrbit);
00470 
00471   if (E != NULL)
00472     {
00473       A = E->removeAttribute(AAttribType);
00474 
00475       if (E->isEmpty())
00476         {
00477           deleteEmbedding(E);
00478           unsetOrbitUsed(AOrbit);
00479         }
00480     }
00481 
00482   return A;
00483 }
00484 //******************************************************************************
00485 INLINE
00486 void CDart::deleteAttribute(TOrbit AOrbit, TAttributeId AAttribType)
00487 {
00488   delete removeAttribute(AOrbit, AAttribType);
00489 }
00490 //******************************************************************************
00491 } // namespace GMap3d
00492 //******************************************************************************