SimplexAdj.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_SimplexAdj_h__)
#define __geom_SimplexAdj_h__

#if defined(DEBUG_geom) && !defined(DEBUG_SimplexAdj)
#define DEBUG_SimplexAdj
#endif

#include "../../defs.h"

#include "VertexSimplexInc.h"

#include <vector>
#include <iosfwd>

BEGIN_NAMESPACE_GEOM


template<int M>
class SimplexAdj {
  //
  // Private types.
  //

private:

  typedef ads::FixedArray<M+1,int> IndexContainer;

  typedef ads::Array<1,IndexContainer> AdjacenciesContainer;

  //
  // Data
  //

private:

  // The array of simplex-simplex adjacencies.
  AdjacenciesContainer _adj;

public:

  //--------------------------------------------------------------------------
  // @{

  SimplexAdj() :
    _adj()
  {}

  SimplexAdj(const SimplexAdj& other) :
    _adj(other._adj)
  {}

  SimplexAdj& 
  operator=(const SimplexAdj& other) {
    if (&other != this) {
      _adj = other._adj;
    }
    return *this;
  }
  

  template<typename IS, bool A>
  SimplexAdj(const ads::Array<1,IS,A>& simplices,
             const VertexSimplexInc<M>& vertexSimplexInc) {
    build(simplices, vertexSimplexInc);
  }

  template<typename IS, bool A>
  void
  build(const ads::Array<1,IS,A>& simplices,
        const VertexSimplexInc<M>& vertexSimplexInc);


  template<typename IS, bool A>
  SimplexAdj(const int numVertices, const ads::Array<1,IS,A>& simplices) {
    build(numVertices, simplices);
  }

  template<typename IS, bool A>
  void
  build(const int numVertices, const ads::Array<1,IS,A>& simplices) {
    VertexSimplexInc<M> vsi(numVertices, simplices);
    build(simplices, vsi);
  }

  void
  swap(SimplexAdj& x) {
    _adj.swap(x._adj);
  }

  ~SimplexAdj()
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  const ads::FixedArray<M+1,int>&
  operator()(const int n) const {
    return _adj[n];
  }

  int
  operator()(const int n, const int m) const {
    return _adj[n][m];
  }

  int
  getSize() const {
    return _adj.size();
  }

  int
  getSize(const int n) const {
    return M + 1 - int(std::count(_adj[n].begin(), _adj[n].end(), -1));
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  ads::FixedArray<M+1,int>&
  operator()(const int n) {
    return _adj[n];
  }

  void
  set(const int n, const int m, const int index) {
    _adj[n][m] = index;
  }

  // @}
  //--------------------------------------------------------------------------


  bool
  operator==(const SimplexAdj& x) const {
    return _adj == x._adj;
  }

  bool
  operator!=(const SimplexAdj& x) const {
    return ! operator==(x);
  }

  // @}
  //--------------------------------------------------------------------------


  void
  put(std::ostream& out) const {
    out << _adj;
  }

};


//
// File output.
//


template<int M>
inline
std::ostream&
operator<<(std::ostream& out, const SimplexAdj<M>& x) {
  x.put(out);
  return out;
}

END_NAMESPACE_GEOM

#define __geom_SimplexAdj_ipp__
#include "SimplexAdj.ipp"
#undef __geom_SimplexAdj_ipp__

#endif

---