referenceelement.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOMETRY_REFERENCEELEMENT_HH
#define DUNE_GEOMETRY_REFERENCEELEMENT_HH
 
#include <dune/geometry/type.hh>
 
namespace Dune {
  namespace Geo {
 
    namespace Impl {
 
      // forward declaration for friend declaration
      template<typename ctype, int dim>
      class ReferenceElementContainer;
 
    }
 
    // forward declaration for constructing default reference element type
    template<typename ctype, int dim>
    class ReferenceElementImplementation;
 
    // forward declaration for backwards compatibility conversion
    template<typename ctype, int dim>
    struct ReferenceElements;
 
    // ReferenceElement
    // ----------------
 
    template<typename Implementation>
    class ReferenceElement
    {
 
    public:
 
#ifndef DOXYGEN
 
      template<int codim>
      using Codim = typename Implementation::template Codim<codim>;
 
#else
 
      template< int codim >
      struct Codim
      {
        using Geometry = implementation-defined;
      };
 
#endif // DOXYGEN
 
      using ctype = typename Implementation::ctype;
 
      using CoordinateField = ctype;
 
      using Coordinate = typename Implementation::Coordinate;
 
      typedef ctype Volume;
 
      static constexpr int dimension = Implementation::dimension;
 
 
      int size(int c) const
      {
        return _impl->size(c);
      }
 
 
      int size(int i, int c, int cc) const
      {
        return _impl->size(i,c,cc);
      }
 
 
      int subEntity(int i, int c, int ii, int cc) const
      {
        return _impl->subEntity(i,c,ii,cc);
      }
 
      auto subEntities ( int i, int c, int cc ) const
      {
        return _impl->subEntities(i,c,cc);
      }
 
 
      decltype(auto) type(int i, int c) const
      {
        return _impl->type(i,c);
      }
 
 
      decltype(auto) type() const
      {
        return _impl->type();
      }
 
 
      decltype(auto) position(int i, int c) const
      {
        return _impl->position(i,c);
      }
 
 
      bool checkInside(const Coordinate& local) const
      {
        return _impl->checkInside(local);
      }
 
 
      template<int codim>
      typename Codim<codim>::Geometry geometry(int i) const
      {
        return _impl->template geometry<codim>(i);
      }
 
 
      CoordinateField volume() const
      {
        return _impl->volume();
      }
 
 
      decltype(auto) integrationOuterNormal(int face) const
      {
        return _impl->integrationOuterNormal(face);
      }
 
 
      ReferenceElement()
        : _impl(nullptr)
      {}
 
      const Implementation& impl() const
      {
        return *_impl;
      }
 
      bool operator==(const ReferenceElement& r) const
      {
        return _impl == r._impl;
      }
 
      bool operator!=(const ReferenceElement& r) const
      {
        return not (*this == r);
      }
 
      friend std::size_t hash_value(const ReferenceElement& r)
      {
        return reinterpret_cast<std::size_t>(r._impl);
      }
 
    private:
 
      // The implementation must be a friend to construct a wrapper around itself.
      friend Implementation;
 
      // The reference container is a friend to be able to call setImplementation.
      friend class Impl::ReferenceElementContainer<ctype,dimension>;
 
      // Constructor for wrapping an implementation reference (required internally by the default implementation)
      ReferenceElement(const Implementation& impl)
        : _impl(&impl)
      {}
 
      void setImplementation(const Implementation& impl)
      {
        _impl = &impl;
      }
 
      const Implementation* _impl;
 
    };
 
  }
 
}
 
 
#endif // DUNE_GEOMETRY_REFERENCEELEMENT_HH