concepts.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CORE_CONCEPTS_HPP_
#define IV_SRC_CORE_CONCEPTS_HPP_
 
#include "core/assert.hpp"
 
#include <compare>
#include <concepts>
#include <cstdint>
#include <ostream>
#include <ranges>
#include <span>
#include <type_traits>
#include <vector>
 
namespace iv
{
 
template<typename T, typename Tag, typename... Capabilities>
class Strong;
 
template<typename... Ts>
struct isStrongType : std::false_type
{
};
 
template<typename... Ts>
struct isStrongType<Strong<Ts...>> : std::true_type
{
};
 
template<typename... Ts>
constexpr bool isStrongTypeV = iv::isStrongType<std::remove_const_t<Ts>...>::value;
 
template<typename T0, typename... Ts>
struct allSame
{
    static constexpr bool value = (std::is_same_v<T0, Ts> && ...);
};
 
template<typename... Ts>
static constexpr bool allSameV = iv::allSame<Ts...>::value;
 
namespace ranges
{
 
template<typename T>
concept spanableRange = std::constructible_from<std::span<const std::ranges::range_value_t<T>>, T>;
 
template<typename T>
concept staticallySpanableRange =
        iv::ranges::spanableRange<T> && decltype(std::span {std::declval<T &>()})::extent != std::dynamic_extent;
 
inline constexpr size_t sizeBytes(iv::ranges::spanableRange auto &&r)
{
    return std::span {r}.size_bytes();
}
 
template<size_t expected, iv::ranges::spanableRange R>
inline constexpr void assertExactByteLength(R &&r)
{
    const std::span s {r};
 
    if constexpr (decltype(s)::extent != std::dynamic_extent)
    {
        static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
    }
    else
    {
        IV_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
    }
}
 
template<iv::ranges::spanableRange R0, iv::ranges::spanableRange... Rs>
inline constexpr void assertEqualByteLengths(R0 &&r0, Rs &&...rs)
    requires(sizeof...(Rs) > 0)
{
    const std::span s0 {r0};
 
    if constexpr (decltype(s0)::extent != std::dynamic_extent)
    {
        constexpr size_t expectedSize = s0.size_bytes();
        (assertExactByteLength<expectedSize>(rs), ...);
    }
    else
    {
        const size_t expectedSize = s0.size_bytes();
 
        IV_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>> {rs}.size_bytes() == expectedSize) && ...),
                     "memory regions don't have equal lengths");
    }
}
 
}// namespace ranges
 
namespace concepts
{
 
template<class T>
concept destructible = std::is_nothrow_destructible_v<T>;
 
template<class T, class... Args>
concept constructibleFrom = destructible<T> && std::is_constructible_v<T, Args...>;
 
template<class T>
concept defaultInitializable = iv::concepts::constructibleFrom<T> && requires { T {}; } &&
                               requires { ::new (static_cast<void *>(nullptr)) T; };
 
template<typename IterT, typename ContainerT>
concept containerIterator =
        std::same_as<IterT, typename ContainerT::iterator> || std::same_as<IterT, typename ContainerT::const_iterator>;
 
template<typename PtrT, typename ContainerT>
concept containerPointer =
        std::same_as<PtrT, typename ContainerT::pointer> || std::same_as<PtrT, typename ContainerT::const_pointer>;
 
template<typename T>
concept container = requires(T a) {
    { a.begin() } -> iv::concepts::containerIterator<T>;
    { a.end() } -> iv::concepts::containerIterator<T>;
    { a.cbegin() } -> iv::concepts::containerIterator<T>;
    { a.cend() } -> iv::concepts::containerIterator<T>;
    { a.size() } -> std::same_as<typename T::size_type>;
    typename T::value_type;
};
 
template<typename T>
concept contiguousContainer = container<T> && requires(T a) {
    { a.data() } -> iv::concepts::containerPointer<T>;
};
 
template<typename T>
concept hasEmpty = requires(T a) {
    { a.empty() } -> std::same_as<bool>;
};
 
template<typename T>
concept resizableContainer = container<T> && requires(T &c, typename T::size_type s) {
    T(s);
    c.resize(s);
};
 
template<typename T>
concept reservableContainer = iv::concepts::container<T> && requires(T &c, typename T::size_type s) { c.reserve(s); };
 
template<typename T>
concept resizableByteBuffer = iv::concepts::contiguousContainer<T> && iv::concepts::resizableContainer<T> &&
                              std::same_as<typename T::value_type, uint8_t>;
 
template<typename T>
concept StringRepresentable = requires(T a) {
    { std::string_view(a) } -> std::convertible_to<std::string_view>;
} || std::same_as<T, char> || std::same_as<T, std::vector<char>>;
 
template<typename T>
concept streamable = requires(std::ostream &os, T a) { os << a; };
 
template<class T>
concept strongType = iv::isStrongTypeV<T>;
 
template<class T>
concept contiguousStrongType = iv::concepts::strongType<T> && iv::concepts::contiguousContainer<T>;
 
template<class T>
concept integralStrongType = iv::concepts::strongType<T> && std::integral<typename T::wrapped_type>;
 
template<class T>
concept unsignedIntegralStrongType = iv::concepts::strongType<T> && std::unsigned_integral<typename T::wrapped_type>;
 
template<typename T, typename Capability>
concept strongTypeWithCapability = T::template hasCapability<Capability>();
 
template<typename T>
concept StreamWritable =
        std::same_as<T, uint8_t> || std::same_as<T, int8_t> || std::same_as<T, uint16_t> || std::same_as<T, int16_t> ||
        std::same_as<T, uint32_t> || std::same_as<T, int32_t> || std::same_as<T, uint64_t> ||
        std::same_as<T, int64_t> || std::same_as<T, double> || std::same_as<T, float> || std::same_as<T, std::string> ||
        std::same_as<T, std::string_view> || std::same_as<T, bool> || std::same_as<T, std::byte>;
 
template<typename T>
concept StreamReadable =
        std::same_as<T, uint8_t> || std::same_as<T, int8_t> || std::same_as<T, uint16_t> || std::same_as<T, int16_t> ||
        std::same_as<T, uint32_t> || std::same_as<T, int32_t> || std::same_as<T, uint64_t> ||
        std::same_as<T, int64_t> || std::same_as<T, double> || std::same_as<T, float> || std::same_as<T, std::string> ||
        std::same_as<T, bool> || std::same_as<T, std::byte>;
 
template<typename T>
concept IntegerType = std::is_same_v<T, uint64_t> || std::is_same_v<T, uint32_t> || std::is_same_v<T, uint16_t> ||
                      std::is_same_v<T, uint8_t> || std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
                      std::is_same_v<T, int16_t>;
 
template<typename T>
concept FloatingPointType = std::is_same_v<T, double> || std::is_same_v<T, float>;
 
template<typename T>
concept EnumType = std::is_enum_v<T>;
 
}// namespace concepts
 
}// namespace iv
 
#endif//IV_SRC_CORE_CONCEPTS_HPP_