concept/concept_tools.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef CONCEPT_TOOLS_HH
# define CONCEPT_TOOLS_HH

# include <type_traits>
# include <memory>
# include <cassert>
# include "../wrappers/operators.hh"
# include "parse_ids.hh"


# define ENABLE_IF(X...) \
  typename = typename std::enable_if< ::catsfoot::eval< X >::value>::type

# define ENABLE_IF_NOT(X...) \
  typename = typename std::enable_if<!::catsfoot::eval< X >::value>::type

# define IF(X...)                               \
  ::catsfoot::eval< X >::value

# define AXIOMS(X...)                                           \
  static auto get_axioms() ->                                   \
    decltype(::catsfoot::details::zip_vec_tuple                 \
             (::catsfoot::details::split_identifiers(#X),       \
              std::make_tuple(X))) {                            \
    return ::catsfoot::details::zip_vec_tuple                   \
      (::catsfoot::details::split_identifiers(#X),              \
       std::make_tuple(X));                                     \
  }


#include "has_requirements.hh"
#include "is_concept.hh"
#include "static_and.hh"

namespace catsfoot {
  template <typename T>
  struct verified: public std::false_type {
  };

  template <typename... T>
  struct concept_list {};

  namespace details {
    template <typename T,
              bool = has_requirements<T>::value,
              bool = is_concept<T>::value,
              bool = is_auto_concept<T>::value>
    struct eval: public T {
    };

    template <typename T, bool B>
    struct eval<T, true, true, B>:
      public static_and<eval<typename T::requirements>,
                        verified<T> > {
    };

    template <typename T>
    struct eval<T, true, false, true>:
      public static_and<eval<typename T::requirements>>
    {
    };

    template <typename... T>
    struct eval<concept_list<T...>, false, false, false>:
      public static_and<eval<T>... > {
    };
  }

  template <typename T>
  struct eval: public details::eval<T> {
  };

  namespace details {
    template <typename T>
    struct class_assert_verified {
      static_assert(verified<T>::value,
                    "Concept was not verified");
    };

    template <typename T,
              bool = is_concept<T>::value,
              bool = is_auto_concept<T>::value,
              bool = has_requirements<T>::value>
    struct class_assert_concept {
      static_assert(T::value, "Missing requirement");
    };

    template <typename F, typename... T, bool A, bool B, bool C>
    struct class_assert_concept<concept_list<F, T...>, A, B, C>:
      public virtual class_assert_concept<F>,
      public virtual class_assert_concept<concept_list<T...> > {
    };

    template <bool A, bool B, bool C>
    struct class_assert_concept<concept_list<>, A, B, C> {
    };

    template <typename T, bool B>
    struct class_assert_concept<T, true, B, true>:
      public virtual class_assert_concept<typename T::requirements>,
      public virtual class_assert_verified<T> {
    };

    template <typename T>
    struct class_assert_concept<T, false, true, true>:
      public class_assert_concept<typename T::requirements> {
    };

  }

  template <typename T>
  struct class_assert_concept:
    public details::class_assert_concept<T> {
  };


  template <typename T>
  void assert_concept(const T&) {
    class_assert_concept<T>();
  }

}

#endif