functionset.hh

#ifndef DUNE_FEM_FUNCTION_COMMON_FUNCTIONSET_HH
#define DUNE_FEM_FUNCTION_COMMON_FUNCTIONSET_HH
 
#include <cassert>
#include <cstddef>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // FunctionSet
    // -----------
 
    template< class FunctionSpace >
    class FunctionSet
    {
    public:
      typedef FunctionSpace FunctionSpaceType;
 
      typedef typename FunctionSpaceType::DomainType DomainType;
      typedef typename FunctionSpaceType::RangeType RangeType;
      typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
      typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
 
      int order () const;
 
      std::size_t size () const;
 
      template< class Functor >
      void evaluateEach ( const DomainType &x, Functor functor ) const;
 
      template< class Functor >
      void jacobianEach ( const DomainType &x, Functor functor ) const;
 
      template< class Functor >
      void hessianEach ( const DomainType &x, Functor functor ) const;
    };
 
 
 
    // FunctionSetProxy
    // ----------------
 
    template< class FunctionSet >
    class FunctionSetProxy
    {
    public:
      typedef FunctionSet ImplementationType;
      const ImplementationType &impl () const
      {
        assert( functionSet_ );
        return *functionSet_;
      }
 
      typedef typename FunctionSet::FunctionSpaceType FunctionSpaceType;;
 
      typedef typename FunctionSet::DomainType DomainType;
      typedef typename FunctionSet::RangeType RangeType;
      typedef typename FunctionSet::JacobianRangeType JacobianRangeType;
      typedef typename FunctionSet::HessianRangeType HessianRangeType;
 
      FunctionSetProxy () : functionSet_( nullptr ) {}
 
      FunctionSetProxy ( const FunctionSet *functionSet )
      : functionSet_( functionSet )
      {}
 
      int order () const { return impl().order(); }
 
      std::size_t size () const { return impl().size(); }
 
      template< class Functor >
      void evaluateEach ( const DomainType &x, Functor functor ) const
      {
        impl().evaluateEach( x, functor );
      }
 
      template< class Functor >
      void jacobianEach ( const DomainType &x, Functor functor ) const
      {
        impl().jacobianEach( x, functor );
      }
      template< class Functor >
      void hessianEach ( const DomainType &x, Functor functor ) const
      {
        impl().hessianEach( x, functor );
      }
 
    private:
      const FunctionSet *functionSet_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_FUNCTION_COMMON_FUNCTIONSET_HH