concept.hpp

Go to the documentation of this file.

//
// Copyright (C) 2014, 2015 Ableton AG, Berlin. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//

#pragma once

#include <atria/estd/type_traits.hpp>
#include <atria/meta/utils.hpp>
#include <atria/meta/pack.hpp>

#include <ableton/build_system/Warnings.hpp>
ABL_DISABLE_WARNINGS
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/apply.hpp>
ABL_RESTORE_WARNINGS
#include <algorithm>

namespace atria {
namespace meta {

constexpr bool all()
{
  return true;
}

template <typename T, typename ...Ts>
constexpr bool all(T x, Ts ...xs)
{
  return x && all(xs...);
}

template <typename ...Ts>
constexpr bool valid()
{
  return true;
}

template <bool Requirement>
using require = estd::enable_if_t<Requirement, int>;

template <typename ...Ts>
void expressions(Ts&&...);

template <typename ConceptSig, typename Enable=void>
struct models
  : std::false_type {};

template <typename ConceptSpecT, typename ...Ts>
struct models<
    ConceptSpecT(Ts...),
    estd::void_t<
        decltype(std::declval<ConceptSpecT>().requires_(
                   std::declval<Ts>()...))
      >
    >
  : std::true_type
{};

template <typename ConceptSpecT, typename T>
struct models_ : models<ConceptSpecT(T)> {};

template<typename ConceptSig>
constexpr bool check()
{
  return check(pack<ConceptSig>{});
}

template<typename ConceptSpecT, typename ...Ts>
constexpr bool check(pack<ConceptSpecT(Ts...)>)
{
  return valid<decltype(
    std::declval<ConceptSpecT>().requires_(
      std::declval<Ts>()...))>();
}

template<template<typename...>class ConceptSpecT, typename ...Ts>
constexpr bool check(pack<ConceptSpecT<Ts...> >)
{
  return valid<decltype(
    std::declval<ConceptSpecT<Ts...> >().requires_(
      std::declval<Ts>()...))>();
}

#define ABL_CONCEPT constexpr

#define ABL_CONCEPT_SPEC(concept_name)                                  \
  struct concept_name ## _spec;                                         \
  template <typename... Ts>                                             \
  ABL_CONCEPT bool concept_name()                                       \
  {                                                                     \
    return ::atria::meta::models<concept_name ## _spec (Ts...)>();      \
  }                                                                     \
  struct concept_name ## _spec
  

template <typename T, typename ...Mfs>
struct if_any;

template <typename T, typename Mf, typename ...Mfs>
struct if_any<T, Mf, Mfs...> : boost::mpl::eval_if<
    typename boost::mpl::apply1<Mf, T>::type,
    std::true_type,
    if_any<T, Mfs...>
  >
{
};

template <typename T, typename Mf>
struct if_any<T, Mf> {
  using type = typename boost::mpl::apply1<Mf, T>::type;
};

template <typename T, typename... Mfs>
using require_any = estd::enable_if_t<
  if_any<T, Mfs...>::type::value,
  int>;


#define ABL_ASSERT_CONCEPT(concept, ...)             \
  static_assert(                                     \
    concept<__VA_ARGS__>(),                          \
    "Concept: " #concept                             \
    " must be satisfied by types: " #__VA_ARGS__)    \
  

#define ABL_ASSERT_NOT_CONCEPT(concept, ...)             \
  static_assert(                                         \
    !concept<__VA_ARGS__>(),                             \
    "Concept: " #concept                                 \
    " must not be satisfied by types: " #__VA_ARGS__)    \
  

} // namespace meta
} // namespace atria