common.h

Go to the documentation of this file.

#pragma once

#include <functional>
#include <type_traits>

#include "stx/config.h"

STX_BEGIN_NAMESPACE

template <typename Fn, typename... Args>
using invoke_result = typename std::invoke_result_t<Fn, Args...>;

template <typename Fn, typename... Args>
constexpr bool invocable = std::is_invocable_v<Fn, Args...>;

template <typename T>
constexpr bool movable = std::is_object_v<T>&& std::is_move_constructible_v<T>&&
    std::is_assignable_v<T&, T>&& std::is_swappable_v<T>;

template <typename T>
constexpr bool copy_constructible = std::is_copy_constructible_v<T>;

template <typename From, typename To>
constexpr bool convertible = std::is_convertible_v<From, To>;

template <typename T, typename Cmp = T, typename = void>
struct is_equality_comparable : std::false_type {};

template <typename T, typename Cmp>
struct is_equality_comparable<
    T, Cmp,
    typename std::enable_if_t<
        true,
        decltype((std::declval<std::remove_reference_t<T> const&>() ==
                  std::declval<std::remove_reference_t<Cmp> const&>()) &&
                     (std::declval<std::remove_reference_t<T> const&>() !=
                      std::declval<std::remove_reference_t<Cmp> const&>()),
                 (void)0)>> : std::true_type {};

template <typename T, typename Cmp = T>
constexpr bool equality_comparable = is_equality_comparable<T, Cmp>::value;

template <typename T>
constexpr bool is_reference = std::is_reference_v<T>;

template <typename T>
using Ref = std::reference_wrapper<T>;

template <typename T>
using ConstRef =
    std::reference_wrapper<std::add_const_t<std::remove_reference_t<T>>>;

template <typename T>
using MutRef =
    std::reference_wrapper<std::remove_const_t<std::remove_reference_t<T>>>;

#if defined(__cpp_concepts)
#if __cpp_concepts >= 201907L
template <typename T, typename Base>
concept Impl = std::is_base_of_v<Base, T>;
#endif
#endif

namespace internal {

constexpr int kxPtrFmtSize = static_cast<int>((sizeof(void*) << 1) + 2 + 2);

// note that the sizes are also affected by the word size. i.e. int64_t and
// size_t will be 32-bit on some platforms, we thus can't allocate less memory
// than required on the stack, though it can be a bit much, such as int64_t on
// 32-bit platforms

constexpr int kI32FmtSize = 11;
constexpr int kU32FmtSize = 10;
constexpr int kI16FmtSize = 6;
constexpr int kU16FmtSize = 5;
constexpr int kI8FmtSize = 4;
constexpr int kU8FmtSize = 3;

}  // namespace internal

STX_END_NAMESPACE