MeshSet.h

Go to the documentation of this file.

#ifndef MeshSet_HEADER
#define MeshSet_HEADER

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <boost/array.hpp>
#include "MeshTypes.h"
#include "Mesh.h"

namespace details {

  /* These should be in MeshSet, but C++ won't abide by a
   * specialized template in non-namespace scope. */


  /***************************************************************************
   * Helper class for MeshSet; use that class instead.
   *
   * To implement MeshVector::get(), I need this other class in order to
   * type-check the more obvious:<code>
   * if (i == topological) {
   *   return meshes_; // type error when i != topological
   * } else {
   *   return lowers_.get<i>();
   * }</code>
   * I came up with the idea of this side template independently, decided it
   * was idiotic, then looked up how boost::tuple does it, and wept.
   *
   * Note that the 'i' template argument here is the number of times to
   * recur into the lower, and is not the dimension.
   ***************************************************************************/
  template <int i> struct MVget {
    template <class MV, class RET>
    static RET& get(MV& mv) {
      return MVget<i-1>::template get<typename MV::lower_type, RET>(mv.lowers_);
    }
  };

  template <> struct MVget<0> {
    template <class MV, class RET>
    static RET& get(MV& mv) {
      return mv.meshes_;
    }
  };

  /***************************************************************************
    * Helper class for MeshSet; use that class instead.
    *
    * Implementation of one dimension of the set of meshes.
    * Each level is a cons cell storing:
    * - the meshes of dimension 'topological'
    * - a lower-dimensional MeshVector
   ***************************************************************************/
  template <size_t ambient, size_t topological> struct MeshVector {
    vector<Mesh<ambient, topological>*> meshes_;
    MeshVector<ambient, topological-1> lowers_;
    typedef MeshVector<ambient, topological-1> lower_type; //<! Used by MVget

    template <size_t i> vector<Mesh<ambient, i>*>& get() {
      BOOST_STATIC_ASSERT(i <= topological);
      BOOST_STATIC_ASSERT(i > 0);
      typedef vector<Mesh<ambient, i>*> RET;
      return MVget<topological - i>::template get<MeshVector, RET>(*this);
    }

    template <size_t i> const vector<Mesh<ambient, i>*>& get() const {
      BOOST_STATIC_ASSERT(i <= topological);
      BOOST_STATIC_ASSERT(i > 0);
      typedef const vector<Mesh<ambient, i>*> RET;
      return MVget<topological - i>::template get<const MeshVector, RET>(*this);
    }

    vector<typename MeshTypes<ambient>::Vertex*>& getVertices() {
      return lowers_.getVertices();
    }

    const vector<typename MeshTypes<ambient>::Vertex*>& getVertices() const {
      return lowers_.getVertices();
    }

    template <class output_iterator> output_iterator outputAllBalls(output_iterator out) const {
      for(size_t i = 0; i < meshes_.size(); ++i) {
        out = meshes_[i]->collectAllBalls(out);
      }
      return lowers_.outputAllBalls(out);
    }

    template <size_t d, class output_iterator> output_iterator outputSomeBalls(output_iterator out) const {
      if (d == topological) {
        for(size_t i = 0; i < meshes_.size(); ++i) {
          out = meshes_[i]->collectAllBalls(out);
        }
        return out;
      } else {
        return lowers_.template outputSomeBalls<d, output_iterator>(out);
      }
    }
  };

  template <size_t ambient> struct MeshVector<ambient, 0> {
    vector<typename MeshTypes<ambient>::Vertex*> verts_;

    vector<typename MeshTypes<ambient>::Vertex*>& getVertices() {
      return verts_;
    }

    const vector<typename MeshTypes<ambient>::Vertex*>& getVertices() const {
      return verts_;
    }

    template <class output_iterator> output_iterator outputAllBalls(const output_iterator& out) const { return out; }
    template <size_t i, class output_iterator> output_iterator outputSomeBalls(const output_iterator& out) const { return out; }
  };
}


/***************************************************************************
 * This class maintains the set of meshes, from dimension 0..d.
 *
 * Most of the work is handed off to the classes in the details namespace
 * above.  Those more naturally fit in MeshSet, but one can't specialize
 * template members of a template for some silly reason.
 *
 * The functions below are templated by the appropriate dimension.  Those that
 * have a function argument of the given dimension can guess the template
 * argument.  Those that can't must be told explicitly; for instance,
 *   <code> ms.get<2>()</code>
 * to get the set of 2-dimensional meshes.  Clearly, the template argument must
 * be a compile-time constant.  Furthermore, in some cases (which this author
 * does not fully understand), that will give an illegible parse error.  Try:
 *   <code> ms.template get<2>()</code>
 * This monstrosity is to deal with the fact that C++ syntax tries
 * very hard to be a context-free grammar.
 ***************************************************************************/
template <size_t ambient>
class MeshSet {
  details::MeshVector<ambient, ambient> meshes_;

  typedef typename MeshTypes<ambient>::Vertex Vertex;

  public:

  /* Monstrously, to call theses functions, you may need to use
     <code>meshes_.template get<i>();</code>
     And so on.
   */

  template <size_t i> void add(Mesh<ambient, i> *mesh) {
    meshes_.get<i>().push_back(mesh);
  }

  void add(Vertex *v) {
    meshes_.getVertices().push_back(v);
  }

  template <size_t i> const vector<Mesh<ambient, i>*>& get() const {
    return meshes_.get<i>();
  }
  Mesh<ambient, ambient> *getTopMesh() const { 
    return meshes_.get<ambient>().front();
  }

  const vector<Vertex*>& getVertices() const {
    return meshes_.getVertices();
  }

  template <class output_iterator> output_iterator outputAllBalls(const output_iterator& out) const {
    return meshes_.outputAllBalls(out);
  }

  template <size_t i, class output_iterator> output_iterator outputSomeBalls(const output_iterator& out) const {
    return meshes_.outputSomeBalls<i, output_iterator>(out);
  }
};

#endif

---