src/lib-gmapkernel/g-map/g-map-basic.hh

Go to the documentation of this file.

/*
 * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-gmapkernel
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#ifndef G_MAP_BASIC_HH
#define G_MAP_BASIC_HH
//******************************************************************************
#include "kernel-types.hh"
#include "inline-macro.hh"

#include <bitset>
//******************************************************************************
namespace GMap3d
{
  class CDart;

  class CGMapBasic
  {
  public:
    // @name Constructeur et destructeur
    // @{

    CGMapBasic();

    virtual ~CGMapBasic();

    // @}
    // @name Réinitialisation de la carte
    // @{

    void randomizeDarts();

    void removeAllDarts();

    virtual void empty();

    // @}
    // @name Gestion des champs direct-info
    // @{

    int getNewDirectInfo();

    void freeDirectInfo(int ADirectIndex);

    void* getDirectInfo(CDart* ADart, int ADirectIndex) const;

    void setDirectInfo(CDart* ADart, int ADirectIndex, void* APointer);

    // @}
    // @name Accès au premier brin de liste des brins de la carte.
    // @{

    CDart* getFirstDart() const;

    void setFirstDart(CDart* ADart);

    // @}
    // @name Gestion des marques
    // @{

    int getNewMark();

    bool getMaskMark(int AMarkNumber) const;

    void freeMark(int AMarkNumber);

    void negateMaskMark(int AMarkNumber);

    bool isWholeMapUnmarked(int AMarkNumber);

    int getNbUsedMarks() const;

    bool isMarked(const CDart* ADart, int AMarkNumber) const;

    void setMarkTo(CDart* ADart, int AMarkNumber, bool AState);

    void setMark(CDart* ADart, int AMarkNumber);

    void unsetMark(CDart* ADart, int AMarkNumber);

    void setMarks(CDart* ADart, const std::bitset<NB_MARKS> & AMarks) const;

    std::bitset<NB_MARKS> getMarks(CDart* ADart) const;

    // @}
    // @name Gestion des orbites utilisées pour les plongements
    // @{

    bool isOrbitUsed(TOrbit AOrbit) const;

    void setOrbitUsed(TOrbit AOrbit);

    void unsetOrbitUsed(TOrbit AOrbit);

    bool isOrbitUsed(CDart* ADart, TOrbit AOrbit) const;

    // @}
    // @name Création et suppression de brins
    // @{

    virtual CDart* newDart();

    virtual void delDart(CDart* ADart);

    CDart* addMapDart();

    void delMapDart(CDart* ADart);

    // @}

    // @{
    bool isFree0(const CDart* ADart) const;
    bool isFree1(const CDart* ADart) const;
    bool isFree2(const CDart* ADart) const;
    bool isFree3(const CDart* ADart) const;
    // @}

    bool isFree(const CDart* ADart, int ADimension) const;

    // @{
    CDart* alpha0(const CDart* ADart) const;
    CDart* alpha1(const CDart* ADart) const;
    CDart* alpha2(const CDart* ADart) const;
    CDart* alpha3(const CDart* ADart) const;
    // @}

    CDart* alpha(const CDart* ADart, int ADimension) const;

    // @{
    void linkAlpha0(CDart* ADart1, CDart* ADart2);
    void linkAlpha1(CDart* ADart1, CDart* ADart2);
    void linkAlpha2(CDart* ADart1, CDart* ADart2);
    void linkAlpha3(CDart* ADart1, CDart* ADart2);
    // @}

    void linkAlpha(CDart* ADart1, CDart* ADart2, int ADimension);

    // @{
    void unlinkAlpha0(CDart* ADart);
    void unlinkAlpha1(CDart* ADart);
    void unlinkAlpha2(CDart* ADart);
    void unlinkAlpha3(CDart* ADart);
    // @}

    void unlinkAlpha(CDart* ADart, int ADimension);

  protected:
    // @name Champs protégés :
    // @{

    CDart* FFirstDart;

    std::bitset<NB_MARKS> FUsedMarks;

    std::bitset<NB_MARKS> FMaskMarks;

    int FMarks[NB_MARKS];

    std::bitset<16> FUsedOrbits;

    std::bitset<NB_DIRECT_INFO> FUsedDirectInfo;

    int FDirectInfos[NB_DIRECT_INFO];

    // @}

  private:
    // @name Champs privés :
    // @{

    int FNbUsedMarks;

    int FNbUsedDirectInfos;

#ifndef NDEBUG
    int FMaxNbUsedMarks;

    int FMaxNbUsedDirectInfos;
#endif // NDEBUG

    // @}
  };

} // namespace GMap3d
//******************************************************************************
#include INCLUDE_INLINE("g-map-basic.icc")
//******************************************************************************
#endif // G_MAP_BASIC_HH
//******************************************************************************

---