DataTransfer.hpp

#pragma once
 
#include <map>
#include <memory>
 
#include <dune/common/concept.hh>
#include <dune/functions/common/typeerasure.hh>
#include <amdis/Output.hpp>
 
namespace AMDiS {
namespace Impl {
 
template <class B, class C>
struct DataTransferDefinition
{
  // Definition of the interface a DataTransfer class must fulfill
  struct Interface
  {
    virtual ~Interface() = default;
    virtual void preAdapt(B const& basis, C const& container, bool mightCoarsen) = 0;
    virtual void adapt(B const& basis, C& container) = 0;
    virtual void postAdapt(C& container) = 0;
  };
 
  // Templatized implementation of the interface
  template <class Impl>
  struct Model : public Impl
  {
    using Impl::Impl;
    void preAdapt(B const& b, C const& c, bool mc) final { this->get().preAdapt(b,c,mc); }
    void adapt(B const& b, C& c) final { this->get().adapt(b,c); }
    void postAdapt(C& c) final { this->get().postAdapt(c); }
  };
 
  // The Concept definition of a DataTransfer
  struct Concept
  {
    template <class DT>
    auto require(DT&& dt) -> decltype
    (
      dt.preAdapt(std::declval<B const&>(), std::declval<C const&>(), true),
      dt.adapt(std::declval<B const&>(), std::declval<C&>()),
      dt.postAdapt(std::declval<C&>())
    );
  };
 
  using Base = Dune::Functions::TypeErasureBase<Interface,Model>;
};
 
} // end namespace Impl
 
 
 
template <class Basis, class Container>
class DataTransfer
    : public Impl::DataTransferDefinition<Basis,Container>::Base
{
  using Definition = Impl::DataTransferDefinition<Basis,Container>;
  using Super = typename Definition::Base;
 
public:
  template <class Impl, Dune::disableCopyMove<DataTransfer,Impl> = 0>
  DataTransfer(Impl&& impl)
    : Super{FWD(impl)}
  {
    static_assert(Concepts::models<typename Definition::Concept(Impl)>,
      "Implementation does not model the DataTransfer concept.");
  }
 
  DataTransfer() = default;
 
 
  void preAdapt(Basis const& basis, Container const& container, bool mightCoarsen)
  {
    this->asInterface().preAdapt(basis, container, mightCoarsen);
  }
 
 
  void adapt(Basis const& basis, Container& container)
  {
    this->asInterface().adapt(basis, container);
  }
 
 
  void postAdapt(Container& container)
  {
    this->asInterface().postAdapt(container);
  }
};
 
 
namespace tag {
 
  struct datatransfer {};
 
} // end namespace tag
 
 
 
template <class Tag>
struct DataTransferFactory
{
  template <class Basis, class Container>
  static DataTransfer<Basis,Container> create(Basis const&, Container const&)
  {
    error_exit("Unknown <tag> passed to the DataTransferFactory.");
    return DataTransfer<Basis,Container>{};
  }
};
 
 
} // end namespace AMDiS