Concepts.hpp

#pragma once

#include <type_traits>

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

#include <dune/amdis/common/ConceptsBase.hpp>
#include <dune/amdis/common/Mpl.hpp>
#include <dune/amdis/common/Utility.hpp>

namespace AMDiS
{
  /**
    * \defgroup Concepts Concepts
    * \brief Concept definitions
    * @{
    **/

  namespace Traits
  {
    template <class A, class B>
    struct IsSimilar
      : std::is_same<std::decay_t<A>, std::decay_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 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
    {
      // a < b
      struct LessThanComparable
      {
        template <class A, class B>
        auto requires_(A&& a, B&& b) -> decltype( a < b );
      };

      // a + b
      struct Addable
      {
        template <class A, class B>
        auto requires_(A&& a, B&& b) -> decltype(
          Concepts::valid_expr(
            a + b,
            b + a
          ));
      };

      // a - b
      struct Subtractable
      {
        template <class A, class B>
        auto requires_(A&& a, B&& b) -> decltype( a - b );
      };

      // a * b
      struct Multiplicable
      {
        template <class A, class B>
        auto requires_(A&& a, B&& b) -> decltype(
          Concepts::valid_expr(
            a * b,
            b * a
          ));
      };

      // a / b
      struct Divisible
      {
        template <class A, class B>
        auto requires_(A&& a, B&& b) -> decltype( a / b );
      };

      // f(args...)
      struct Callable
      {
        template <class F, class... Args>
        auto requires_(F&& f, Args&&... args) -> decltype( f(std::forward<Args>(args)...));
      };

      // f(args...)
      struct Evaluable
      {
        template <class F, class... Args>
        auto requires_(F&& f, Args&&... args) -> Void_t<
          decltype( f(std::forward<Args>(args)...)),
          std::result_of_t<std::decay_t<F>(std::decay_t<Args>...)>
          >;
      };

      // idx[0]
      struct MultiIndex
      {
        template <class MI>
        auto requires_(MI&& idx) -> decltype(
          Concepts::valid_expr(
            idx[0],
            idx.size(),
            idx.max_size()
            /* ,idx.resize() */
          ));
      };

    } // end namespace Definition
#endif // DOXYGEN


    /// \brief Argument `A` is (implicitly) convertible to arguemnt `B` and vice versa.
    template <class A, class B >
    constexpr bool Convertible = std::is_convertible<A,B>::value && std::is_convertible<B,A>::value;

    /// Types are the same, up to decay of qualifiers
    template <class A, class B>
    constexpr bool Similar = Traits::IsSimilar<A, B>::value;

    /// \brief Argument A is less-than comparable to type B, i.e. A < B is valid
    template <class A, class B = A>
    constexpr bool LessThanComparable = models<Definition::LessThanComparable(A, B)>;

    /// \brief Argument A is addable to type B, i.e. A + B is valid
    template <class A, class B>
    constexpr bool Addable = models<Definition::Addable(A, B)>;

    /// \brief Argument A is subtractable by type B, i.e. A - B is valid
    template <class A, class B>
    constexpr bool Subtractable = models<Definition::Subtractable(A, B)>;

    /// \brief Argument A is multiplicable by type B, i.e. A * B is valid
    template <class A, class B>
    constexpr bool Multiplicable = models<Definition::Multiplicable(A, B)>;

    /// \brief Argument A is divisible by type B, i.e. A / B is valid
    template <class A, class B>
    constexpr bool Divisible = models<Definition::Divisible(A, B)>;

    /// \brief A Collable is a function `F` that can be called with arguments of type `Args...`.
    /**
      * To be used as follows: `Concepts::Collable<F, Args...>`. Returns true, if
      * an instance of `F` can be called by `operator()` with arguments of type
      * `Args...`.
      **/
    template <class F, class... Args>
    constexpr bool Callable = models<Definition::Callable(F, Args...)>;

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


    /// \brief A Functor is a function `F` with signature `Signature`.
    /**
      * To be used as follows: `Concepts::Functor<F, R(Args...)>`. Returns true, if
      * an instance of `F` can be called by `operator()` with arguments of type
      * `Args...` and returns a value of type `R`, i.e. `Signature := R(Args...)`.
      **/
    template <class F, class Signature> // F, Signature=Return(Arg)
    constexpr bool Functor = Dune::Functions::Concept::isFunction<F, Signature>();

    /// A predicate is a function that returns a boolean.
    template <class F, class... Args>
    constexpr bool Predicate = Functor<F, bool(Args...)>;

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

    /** @} **/

  } // end namespace Concepts

} // end namespace AMDiS