Concepts.hpp

Go to the documentation of this file.

 
//                Copyright Oliver J. Rosten 2020.                //
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0. //
//    (See accompanying file LICENSE.md or copy at                //
//          https://www.gnu.org/licenses/gpl-3.0.en.html)         //
 
#pragma once
 
#include "sequoia/Core/Meta/TypeTraits.hpp"
 
#include <utility>
#include <functional>
#include <concepts>
 
namespace sequoia
{
  template <class F, class R, class... Args>
  concept invocable_r =
    requires(F&& f, Args&&... args) {
      { std::invoke(std::forward<F>(f), std::forward<Args>(args)...) } -> std::same_as<R>;
  };
 
  template <class F, class R, class... Args>
  concept regular_invocable_r = invocable_r<F, R, Args...>;
 
  template <class T>
  concept movable_comparable = std::movable<T> && std::equality_comparable<T>;
 
  template <class T>
  concept pseudoregular = movable_comparable<T> && std::copyable<T>;
 
  template <class T>
  concept moveonly = movable_comparable<T> && !std::copyable<T>;
 
 
  template <class A>
  concept alloc = requires(A& a) {
    a.allocate(0);
  };
 
  template <class A>
  concept scoped_alloc = alloc<A> && requires() {
    typename A::outer_allocator_type;
    typename A::inner_allocator_type;
  };
 
  template<class T, class Stream>
  concept serializable_to = requires(std::remove_reference_t<Stream>& stream, const std::remove_reference_t<T>& t) {
    typename Stream::char_type;
    stream << t;
  };
 
  template<class T, class Stream>
  concept deserializable_from = requires(std::remove_reference_t<Stream>& stream, std::remove_reference_t<T>& t) {
    typename Stream::char_type;
    stream >> t;
  };
 
  template<class T, class... Args>
  concept initializable_from = requires{
    T{std::declval<Args>()...};
  };
 
  template<class T>
  concept arithmetic = std::is_arithmetic_v<T>;
 
  template<class T>
  concept faithful_range = requires(T& t) {
    std::ranges::begin(t);
    std::ranges::end(t);
 
    requires (!std::same_as<std::remove_cvref_t<decltype(*std::ranges::begin(t))>, std::remove_cvref_t<T>>);
  };
 
  template<class T>
  concept deep_equality_comparable = is_deep_equality_comparable_v<T>;
 
}