BoundaryCondition.hpp

#pragma once
 
#include <type_traits>
 
#include <dune/functions/common/typeerasure.hh>
 
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/TypeTraits.hpp>
 
 
namespace AMDiS {
namespace Impl {
 
template <class Mat, class Sol, class Rhs>
struct BoundaryConditionDefinition
{
  // Definition of the interface a BoundaryCondition must fulfill
  struct Interface
  {
    virtual ~Interface() = default;
    virtual void init() = 0;
    virtual void apply(Mat&, Sol&, Rhs&) = 0;
  };
 
  // Templatized implementation of the interface
  template <class Impl>
  struct Model : public Impl
  {
    using Impl::Impl;
    void init() final { this->get().init(); }
    void apply(Mat& A, Sol& x, Rhs& b) final { this->get().apply(A,x,b); }
  };
 
  // The Concept definition of a BoundaryCondition
  struct Concept
  {
    template <class BC>
    auto require(BC&& bc) -> decltype
    (
      bc.init(),
      bc.apply(std::declval<Mat&>(), std::declval<Sol&>(), std::declval<Rhs&>())
    );
  };
 
  using Base = Dune::Functions::TypeErasureBase<Interface, Model>;
};
 
} // end namespace Impl
 
 
 
template <class Mat, class Sol, class Rhs>
class BoundaryCondition
    : public Impl::BoundaryConditionDefinition<Mat,Sol,Rhs>::Base
{
  using Definition = Impl::BoundaryConditionDefinition<Mat,Sol,Rhs>;
  using Super = typename Definition::Base;
 
public:
  template <class Impl, Dune::disableCopyMove<BoundaryCondition,Impl> = 0>
  BoundaryCondition(Impl&& impl)
    : Super{FWD(impl)}
  {
    static_assert(Concepts::models<typename Definition::Concept(Impl)>,
      "Implementation does not model the BoundaryCondition concept.");
  }
 
  BoundaryCondition() = default;
 
 
  void init()
  {
    this->asInterface().init();
  }
 
 
  void apply(Mat& A, Sol& x, Rhs& b)
  {
    this->asInterface().apply(A,x,b);
  }
};
 
 
} // end namespace AMDiS