IndSimpSet.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_IndSimpSet_h__)
#define __geom_IndSimpSet_h__

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

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

#include "SimplexIterator.h"

#include "../simplex/Simplex.h"

#include "../../../ads/array/Array.h"

#include <cassert>

BEGIN_NAMESPACE_GEOM

// CONTINUE: Perhaps Mutable should be a template parameter.

template<int _N,
         int _M = _N,
         bool _A = true,
         typename T = double,
         typename V = ads::FixedArray<_N,T>,
         typename IS = Simplex<_M,int> >
class IndSimpSet {
  //
  // Enumerations.
  //

public:

  enum {N = _N, M = _M, A = _A};

  //
  // Public types.
  //

public:

  typedef T Number;
  typedef V Vertex;
  typedef geom::Simplex<M,Vertex> Simplex;
  typedef typename Simplex::Face SimplexFace;

  typedef IS IndexedSimplex;
  typedef typename IndexedSimplex::Face IndexedSimplexFace;

  typedef ads::Array<1,Vertex,A> VertexContainer;
  typedef typename VertexContainer::const_iterator VertexConstIterator;
  typedef typename VertexContainer::iterator VertexIterator;

  typedef ads::Array<1,IndexedSimplex,A> IndexedSimplexContainer;
  typedef typename IndexedSimplexContainer::const_iterator 
  IndexedSimplexConstIterator;
  typedef typename IndexedSimplexContainer::iterator 
  IndexedSimplexIterator;

  typedef SimplexIterator<IndSimpSet> SimplexConstIterator;

  typedef typename VertexContainer::size_type SizeType;

private:

  //
  // Data
  //

  VertexContainer _vertices;

  IndexedSimplexContainer _indexedSimplices;

public:

  //--------------------------------------------------------------------------


  IndSimpSet() :
    _vertices(),
    _indexedSimplices()
  {}


  template<bool A1, bool A2>
  IndSimpSet
  (const ads::Array<1,Vertex,A1>& vertices, 
   const ads::Array<1,IndexedSimplex,A2>& indexedSimplices) :
    _vertices(vertices),
    _indexedSimplices(indexedSimplices)
  {}


  template<bool A1, bool A2>
  void
  build(const ads::Array<1,Vertex,A1>& vertices, 
        const ads::Array<1,IndexedSimplex,A2>& indexedSimplices) {
    _vertices = vertices;
    _indexedSimplices = indexedSimplices;
    updateTopology();
  }


  IndSimpSet(const SizeType numVertices, 
             void* vertices,
             const SizeType numSimplices, 
             void* indexedSimplices) :
    _vertices(numVertices, vertices),
    _indexedSimplices(numSimplices, indexedSimplices)
  {}


  void
  build(const SizeType numVertices, void* vertices,
        const SizeType numSimplices, void* indexedSimplices);


  IndSimpSet(const SizeType numVertices, 
             const void* vertices,
             const SizeType numSimplices, 
             const void* indexedSimplices) :
    _vertices(numVertices, vertices),
    _indexedSimplices(numSimplices, indexedSimplices)
  {
    LOKI_STATIC_CHECK(A == true, MustAllocateOwnMemory);
  }


  void
  build(const SizeType numVertices, const void* vertices,
        const SizeType numSimplices, const void* indexedSimplices);


  IndSimpSet(const SizeType numVertices, const SizeType numSimplices) :
    _vertices(numVertices),
    _indexedSimplices(numSimplices)
  {}


  void
  build(const SizeType numVertices, const SizeType numSimplices) {
    _vertices.resize(numVertices);
    _indexedSimplices.resize(numSimplices);
  }

  void
  swap(IndSimpSet& x) {
    _vertices.swap(x._vertices);
    _indexedSimplices.swap(x._indexedSimplices);
  }

  IndSimpSet(const IndSimpSet& other) :
    _vertices(other._vertices),
    _indexedSimplices(other._indexedSimplices)
  {}

  IndSimpSet&
  operator=(const IndSimpSet& other);

  virtual
  ~IndSimpSet()
  {}

  //--------------------------------------------------------------------------

  int
  getSpaceDimension() const {
    return N;
  }

  SizeType
  getVerticesSize() const {
    return _vertices.size();
  }

  SizeType
  areVerticesEmpty() const {
    return getVerticesSize() == 0;
  }

  VertexConstIterator
  getVerticesBeginning() const { 
    return _vertices.begin();
  }

  VertexConstIterator
  getVerticesEnd() const { 
    return _vertices.end();
  }

  const Vertex&
  getVertex(const int n) const {
    return _vertices[n];
  }

  const VertexContainer&
  getVertices() const {
    return _vertices;
  }

  //--------------------------------------------------------------------------

  int
  getSimplexDimension() const {
    return M;
  }

  SizeType
  getSimplicesSize() const {
    return _indexedSimplices.size();
  }

  SizeType
  areSimplicesEmpty() const {
    return getSimplicesSize() == 0;
  }

  SizeType
  isEmpty() const {
    return areVerticesEmpty() && areSimplicesEmpty();
  }

  IndexedSimplexConstIterator
  getIndexedSimplicesBeginning() const { 
    return _indexedSimplices.begin();
  }

  IndexedSimplexConstIterator
  getIndexedSimplicesEnd() const { 
    return _indexedSimplices.end();
  }

  const IndexedSimplex&
  getIndexedSimplex(const int n) const {
    return _indexedSimplices[n];
  }

  const IndexedSimplexContainer&
  getIndexedSimplices() const {
    return _indexedSimplices;
  }

  SimplexConstIterator
  getSimplicesBeginning() const {
    return SimplexConstIterator(*this);
  }

  SimplexConstIterator
  getSimplicesEnd() const {
    SimplexConstIterator i(*this);
    i += getSimplicesSize();
    return i;
  }

  const Vertex&
  getSimplexVertex(const int n, const int m) const {
    return _vertices[_indexedSimplices[n][m]];
  }

  void
  getSimplex(const int n, Simplex* s) const {
    getSimplex(_indexedSimplices.begin() + n, s);
  }

  void
  getSimplex(IndexedSimplexConstIterator i, Simplex* s) const {
    for (int m = 0; m != M+1; ++m) {
      (*s)[m] = _vertices[(*i)[m]];
    }
  }

  //--------------------------------------------------------------------------

  VertexIterator
  getVerticesBeginning() { 
    return _vertices.begin();
  }

  VertexIterator
  getVerticesEnd() { 
    return _vertices.end();
  }

  void
  setVertex(const int n, const Vertex& vertex) {
    _vertices[n] = vertex;
  }

  VertexContainer&
  getVertices() {
    return _vertices;
  }

  //--------------------------------------------------------------------------

  IndexedSimplexIterator
  getIndexedSimplicesBeginning() { 
    return _indexedSimplices.begin();
  }

  IndexedSimplexIterator
  getIndexedSimplicesEnd() { 
    return _indexedSimplices.end();
  }

  IndexedSimplexContainer&
  getIndexedSimplices() {
    return _indexedSimplices;
  }

  //--------------------------------------------------------------------------


  virtual
  void
  updateTopology()
  {}
  
};

END_NAMESPACE_GEOM

#define __geom_IndSimpSet_ipp__
#include "IndSimpSet.ipp"
#undef __geom_IndSimpSet_ipp__

#endif

---