Operator.hpp

#pragma once
 
#include <type_traits>
 
#include <dune/common/concept.hh>
#include <dune/functions/common/typeerasure.hh>
 
#include <amdis/LocalOperator.hpp>
#include <amdis/common/ConceptsBase.hpp>
 
namespace AMDiS {
namespace Impl {
 
template <class GV, class LC, class C>
struct OperatorTraits
{
  using GridView = GV;
  using LocalContext = LC;
  using ElementContainer = C;
};
 
template <class Traits, class... Nodes>
struct OperatorDefinition
{
  using GridView = typename Traits::GridView;
 
  // Definition of the interface an Operator must fulfill
  struct Interface
  {
    virtual ~Interface() = default;
    virtual void update(GridView const&) = 0;
    virtual LocalOperator<Traits,Nodes...> asLocalOperator() const = 0;
  };
 
  // Templatized implementation of the interface
  template <class Impl>
  struct Model : public Impl
  {
    using Impl::Impl;
    void update(GridView const& gv) final { this->get().update(gv); }
    LocalOperator<Traits,Nodes...> asLocalOperator() const final {
      return localOperator(this->get()); }
  };
 
  // The Concept definition of an Operator
  struct Concept
  {
    using LOpConcept = typename LocalOperatorDefinition<Traits,Nodes...>::Concept;
 
    template <class Op>
    auto require(Op&& op) -> decltype
    (
      op.update(std::declval<GridView>()),
      Dune::Concept::requireConcept<LOpConcept>(localOperator(op))
    );
  };
 
  using Base = Dune::Functions::TypeErasureBase<Interface,Model>;
};
 
} // end namespace Impl
 
 
 
template <class Traits, class... Nodes>
class Operator
    : public Impl::OperatorDefinition<Traits,Nodes...>::Base
{
  using Definition = Impl::OperatorDefinition<Traits,Nodes...>;
  using Super = typename Definition::Base;
 
public:
  // The gridview the operator is associated to
  using GridView = typename Traits::GridView;
 
public:
  template <class Impl, Dune::disableCopyMove<Operator,Impl> = 0>
  Operator(Impl&& impl)
    : Super{FWD(impl)}
  {
    static_assert(Concepts::models<typename Definition::Concept(Impl)>,
      "Implementation does not model the Operator concept.");
  }
 
  Operator() = default;
 
  void update(GridView const& gv)
  {
    this->asInterface().update(gv);
  }
 
  friend LocalOperator<Traits,Nodes...> localOperator(Operator const& op)
  {
    return op.asInterface().asLocalOperator();
  }
};
 
template <class LocalContext, class Op, class GV>
auto makeOperator(Op op, GV const& gridView)
{
  op.update(gridView);
  return op;
}
 
} // end namespace AMDiS