concept.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <type_traits>
#include <variant>
#include <vector>
#include <optional>
#include <ranges>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <memory>

namespace ns_concept
{
 
// ============================================================================
// Template Metaprogramming Utilities
// ============================================================================

template<typename T, template<typename...> typename U>
inline constexpr bool is_instance_of_v = std::false_type {};

template<template<typename...> typename U, typename... Args>
inline constexpr bool is_instance_of_v<U<Args...>,U> = std::true_type {};

template<typename T, template<typename...> typename U>
concept IsInstanceOf = is_instance_of_v<std::remove_cvref_t<T>, U>;
 
static_assert(!IsInstanceOf<std::vector<int>*, std::vector>);
static_assert( IsInstanceOf<std::vector<int>&, std::vector>);
static_assert( IsInstanceOf<std::vector<int> const&, std::vector>);
static_assert( IsInstanceOf<std::vector<int>, std::vector>);
static_assert( IsInstanceOf<std::vector<std::string>, std::vector>);
static_assert(!IsInstanceOf<std::string, std::vector>);
static_assert( IsInstanceOf<std::optional<int>, std::optional>);
 
// ============================================================================
// Boolean and Logical Concepts
// ============================================================================

template<typename T>
concept Boolean = std::convertible_to<std::remove_cvref_t<T>, bool>
&& requires(T t)
{
  { !t } -> std::convertible_to<bool>;
};
 
static_assert( Boolean<bool const&>);
static_assert( Boolean<bool &>);
static_assert( Boolean<int const&>);
static_assert( Boolean<int &>);
static_assert( Boolean<void*>);
static_assert(!Boolean<std::string>);
static_assert(!Boolean<std::vector<int>>);
 
// ============================================================================
// Enum Concepts
// ============================================================================

template<typename T>
concept Enum = std::is_enum_v<T>;
 
enum TestEnum { VALUE1, VALUE2 };
enum class TestEnumClass { VALUE1, VALUE2 };
static_assert( Enum<TestEnum>);
static_assert( Enum<TestEnumClass>);
static_assert(!Enum<int>);
static_assert(!Enum<std::string>);

template<typename T>
concept ScopedEnum = Enum<T> && !std::is_convertible_v<T, std::underlying_type_t<T>>;
 
static_assert(!ScopedEnum<TestEnum>);
static_assert( ScopedEnum<TestEnumClass>);
 
// ============================================================================
// Variant Concepts
// ============================================================================

template <typename T, typename... Args>
concept Variant = IsInstanceOf<T, std::variant>;
 
static_assert( Variant<std::variant<int, std::string>>);
static_assert( Variant<std::variant<int>>);
static_assert(!Variant<int>);
static_assert(!Variant<std::optional<int>>);
 
// ============================================================================
// Type Equality Concepts
// ============================================================================

template<typename T, typename... U>
concept Uniform = ( std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>> and ... );
 
static_assert( Uniform<int, int>);
static_assert(!Uniform<int, long>);
static_assert(!Uniform<int, int, long, short>);
static_assert( Uniform<const int&, int>);
static_assert(!Uniform<int, std::string>);
static_assert(!Uniform<int, double, float, std::string>);
 
// ============================================================================
// Iterator and Range Concepts
// ============================================================================

template<typename T>
concept Iterable = std::ranges::range<T>;
 
static_assert( Iterable<std::vector<int>>);
static_assert( Iterable<std::string>);
static_assert( Iterable<int[5]>);
static_assert(!Iterable<int>);
static_assert(!Iterable<void*>);
 
// ============================================================================
// Container Concepts
// ============================================================================

template <typename T, typename U>
concept IsContainerOf = requires
{
  typename T::value_type;
  requires std::same_as<typename T::value_type, U>;
  requires Iterable<T>;
};
 
static_assert( IsContainerOf<std::vector<int>, int>);
static_assert( IsContainerOf<std::vector<std::string>, std::string>);
static_assert(!IsContainerOf<std::vector<int>, double>);
static_assert(!IsContainerOf<int, int>);

template <typename T>
concept IsVector = IsInstanceOf<T, std::vector>;
 
static_assert( IsVector<std::vector<int>>);
static_assert( IsVector<std::vector<std::string>>);
static_assert(!IsVector<std::string>);
static_assert(!IsVector<int>);

template <typename T>
concept IsOptional = IsInstanceOf<T, std::optional>;
 
static_assert( IsOptional<std::optional<int>>);
static_assert( IsOptional<std::optional<std::string>>);
static_assert(!IsOptional<int>);
static_assert(!IsOptional<std::vector<int>>);

template <typename T>
concept Container = IsInstanceOf<T, std::vector>
  or IsInstanceOf<T, std::deque>
  or IsInstanceOf<T, std::list>
  or IsInstanceOf<T, std::set>
  or IsInstanceOf<T, std::map>
  or IsInstanceOf<T, std::unordered_set>
  or IsInstanceOf<T, std::unordered_map>;
 
static_assert( Container<std::vector<int>>);
static_assert( Container<std::vector<std::string>>);
static_assert( Container<std::deque<double>>);
static_assert( Container<std::list<int>>);
static_assert( Container<std::set<int>>);
static_assert( Container<std::map<std::string, int>>);
static_assert( Container<std::unordered_set<int>>);
static_assert( Container<std::unordered_map<std::string, int>>);
static_assert(!Container<int>);
static_assert(!Container<int[10]>);
static_assert(!Container<std::optional<int>>);
static_assert(!Container<std::string>);
 
// ============================================================================
// String Concepts
// ============================================================================

template<typename T>
concept StringConvertible = std::is_convertible_v<std::remove_cvref_t<T>, std::string>;
 
static_assert( StringConvertible<std::string>);
static_assert( StringConvertible<const char*>);
static_assert(!StringConvertible<int>);
static_assert(!StringConvertible<std::vector<char>>);

template<typename T>
concept StringConstructible = std::constructible_from<std::string, std::remove_cvref_t<T>>;
 
static_assert( StringConstructible<const char*>);
static_assert( StringConstructible<std::string>);
static_assert(!StringConstructible<int>);
static_assert(!StringConstructible<void*>);
 
// ============================================================================
// Numeric Concepts
// ============================================================================

template<typename T>
concept Numeric = std::integral<std::remove_cvref_t<T>> or std::floating_point<std::remove_cvref_t<T>>;
 
// Static assertions for Numeric
static_assert( Numeric<int>);
static_assert( Numeric<double>);
static_assert( Numeric<float>);
static_assert( Numeric<long long>);
static_assert( Numeric<unsigned int>);
static_assert(!Numeric<std::string>);
static_assert(!Numeric<void*>);
 
// ============================================================================
// Stream and Formatting Concepts
// ============================================================================

template<typename T>
concept StreamInsertable = requires(T t, std::ostream& os)
{
  { os << t } -> std::same_as<std::ostream&>;
};
 
// Static assertions for StreamInsertable
static_assert( StreamInsertable<int>);
static_assert( StreamInsertable<std::string>);
static_assert( StreamInsertable<double>);
static_assert(!StreamInsertable<std::vector<int>>);

template<typename T>
concept StringRepresentable = StringConvertible<T>
  or StringConstructible<T>
  or Numeric<T>
  or StreamInsertable<T>;
 
static_assert( StringRepresentable<int>);
static_assert( StringRepresentable<std::string>);
static_assert( StringRepresentable<const char*>);
static_assert( StringRepresentable<double>);
static_assert(!StringRepresentable<std::vector<int>>);
 
} // namespace ns_concept
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/