Concepts.hpp

#pragma once

#include <type_traits>

#include <dune/functions/common/functionconcepts.hh>
#include <dune/functions/functionspacebases/concepts.hh>

#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Logical.hpp>
#include <amdis/common/TypeTraits.hpp>

namespace AMDiS
{
  namespace Traits
  {
    template <class A, class B>
    struct IsSimilar
      : std::is_same<remove_cvref_t<A>, remove_cvref_t<B>> {};

    template <class A, class B>
    struct IsSimilar<Types<A>, Types<B>>
      : IsSimilar<A,B> {};

    template <>
    struct IsSimilar<Types<>, Types<>> : std::true_type {};

    template <class A0, class... As, class B0, class... Bs>
    struct IsSimilar<Types<A0,As...>, Types<B0,Bs...>>
      : and_t<IsSimilar<A0, B0>::value, IsSimilar<Types<As...>, Types<Bs...>>::value> {};


    template <class... Ts>
    struct IsSame;

    template <class T0, class... Ts>
    struct IsSame<T0, Ts...>
      : std::is_same<Types<T0,Ts...>, Types<Ts...,T0>> {};

    template <>
    struct IsSame<> : std::true_type {};


    template <class T>
    struct IsReferenceWrapper
      : std::false_type {};

    template <class T>
    struct IsReferenceWrapper<std::reference_wrapper<T>>
      : std::true_type {};

  } // end namespace Traits


  namespace Concepts
  {
#ifndef DOXYGEN
    namespace Definition
    {
      // f(args...)
      struct Callable
      {
        template <class F, class... Args>
        auto require(F&& f, Args&&... args) -> decltype(
          f(FWD(args)...)
        );
      };

      // idx[0]
      struct MultiIndex
      {
        template <class MI>
        auto require(MI&& idx) -> decltype(
          idx[0],
          idx.size(),
          idx.max_size()
        );
      };

      template <class MultiIndex>
      struct PreBasisFactory
      {
        template <class PBF, class GV>
        auto require(PBF const& pbf, GV const& gridView) -> decltype(
          pbf.template makePreBasis<MultiIndex>(gridView)
        );
      };

    } // end namespace Definition
#endif // DOXYGEN


    template <class... Ts>
    constexpr bool Same = Traits::IsSame<Ts...>::value;

    template <class... Ts>
    using Same_t = Traits::IsSame<Ts...>;


    template <class A, class B>
    constexpr bool Similar = Traits::IsSimilar<A, B>::value;

    template <class A, class B>
    using Similar_t = Traits::IsSimilar<A, B>;



    template <class F, class... Args>
    constexpr bool Callable = models<Definition::Callable(F, Args...)>;

    template <class F, class... Args>
    using Callable_t = models_t<Definition::Callable(F, Args...)>;



    template <class F, class Signature> // F, Signature=Return(Arg)
    constexpr bool Functor = Dune::Functions::Concept::isFunction<F, Signature>();

    template <class F, class Signature> // F, Signature=Return(Arg)
    using Functor_t = bool_t<Functor<F,Signature>>;


    template <class F, class... Args>
    constexpr bool Predicate = Functor<F, bool(Args...)>;

    template <class F, class... Args>
    using Predicate_t = Functor_t<F, bool(Args...)>;


    template <class MI>
    constexpr bool MultiIndex = models<Definition::MultiIndex(MI)>;

    template <class MI>
    using MultiIndex_t = models_t<Definition::MultiIndex(MI)>;


    template <class Range, class Index>
    constexpr bool HasIndexAccess = models<Dune::Functions::Concept::HasIndexAccess(Range, Index)>;

    template <class Range, class Index>
    using HasIndexAccess_t = models_t<Dune::Functions::Concept::HasIndexAccess(Range, Index)>;


    template <class N>
    constexpr bool BasisNode = models<Dune::Functions::Concept::BasisNode(N)>;

    template <class N>
    using BasisNode_t = models_t<Dune::Functions::Concept::BasisNode(N)>;


    template <class Tree, class GV>
    constexpr bool BasisTree = models<Dune::Functions::Concept::BasisTree<GV>(Tree)>;

    template <class Tree, class GV>
    using BasisTree_t = models_t<Dune::Functions::Concept::BasisTree<GV>(Tree)>;


    template <class LV, class GB = typename LV::GlobalBasis>
    constexpr bool LocalView = models<Dune::Functions::Concept::LocalView<GB>(LV)>;

    template <class LV, class GB = typename LV::GlobalBasis>
    using LocalView_t = models_t<Dune::Functions::Concept::LocalView<GB>(LV)>;


    template <class GB, class GV = typename GB::GridView>
    constexpr bool GlobalBasis = models<Dune::Functions::Concept::GlobalBasis<GV>(GB)>;

    template <class GB, class GV = typename GB::GridView>
    using GlobalBasis_t = models_t<Dune::Functions::Concept::GlobalBasis<GV>(GB)>;

    template <class PBF, class GV, class MI = std::array<std::size_t,1>>
    constexpr bool PreBasisFactory = models<Definition::PreBasisFactory<MI>(PBF,GV)>;

    template <class PBF, class GV, class MI = std::array<std::size_t,1>>
    using PreBasisFactory_t = models_t<Definition::PreBasisFactory<MI>(PBF,GV)>;

  } // end namespace Concepts
} // end namespace AMDiS