traits.h

Go to the documentation of this file.

/* *****************************************************************************
 * kblib is a general utility library for C++14 and C++17, intended to provide
 * performant high-level abstractions and more expressive ways to do simple
 * things.
 *
 * Copyright (c) 2021 killerbee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 * ****************************************************************************/
 
#ifndef KBLIB_TRAITS_H_INCLUDED_
#define KBLIB_TRAITS_H_INCLUDED_
 
#include "fakestd.h"
#include "tdecl.h"
 
#include <array>
#include <cstring>
#include <tuple>
#include <type_traits>
 
namespace KBLIB_NS {
 
// contains_types adapted from code by Maarten Bamelis,
// https://stackoverflow.com/a/42581257/1924641
 
template <typename Tuple, typename T>
struct contains_type;
 
template <typename T, typename U, typename... Ts>
struct contains_type<std::tuple<T, Ts...>, U>
    : contains_type<std::tuple<Ts...>, U> {};
 
template <typename T, typename... Ts>
struct contains_type<std::tuple<T, Ts...>, T> : std::true_type {};
 
template <typename T>
struct contains_type<std::tuple<>, T> : std::false_type {};
 
template <typename... Ts>
KBLIB_CONSTANT_V contains_type_v = contains_type<Ts...>::value;
 
template <typename Lhs, typename Rhs>
struct contains_types;
 
template <typename Tuple, typename T, typename... Ts>
struct contains_types<Tuple, std::tuple<T, Ts...>>
    : std::integral_constant<
          bool, contains_type<Tuple, T>::value
                    and contains_types<Tuple, std::tuple<Ts...>>::value> {};
 
template <typename Tuple>
struct contains_types<Tuple, std::tuple<>> : std::true_type {};
 
template <typename... Ts>
KBLIB_CONSTANT_V contains_types_v = contains_types<Ts...>::value;
 
template <typename T>
struct list_as_tuple;
 
template <template <typename...> class Tuple, typename... Ts>
struct list_as_tuple<Tuple<Ts...>> {
   using type = std::tuple<Ts...>;
};
 
namespace detail {
 
   template <typename T, int N, int... I>
   KBLIB_NODISCARD constexpr auto trim_array(const T (&arr)[N],
                                             std::integer_sequence<int, I...>)
       -> std::array<T, std::integer_sequence<int, I...>::size()> {
      return {arr[I]...};
   }
 
} // namespace detail
 
template <int trim, typename T, int N,
          typename Indices = std::make_integer_sequence<int, N - trim>>
KBLIB_NODISCARD constexpr auto trim_array(const T (&arr)[N])
    -> std::array<T, N - trim> {
   return detail::trim_array(arr, Indices{});
}
 
template <int N, typename Indices = std::make_integer_sequence<int, N - 1>>
KBLIB_NODISCARD constexpr auto remove_null_terminator(const char (&arr)[N])
    -> std::array<char, N - 1> {
   return detail::trim_array(arr, Indices{});
}
 
template <typename T>
struct is_unbounded_array : std::false_type {};
template <typename T>
struct is_unbounded_array<T[]> : std::true_type {};
 
template <typename T>
struct is_bounded_array : std::false_type {};
template <typename T, std::size_t N>
struct is_bounded_array<T[N]> : std::true_type {};
 
template <typename T>
using alias = T;
 
template <typename, typename T>
struct ignore {
   using type = T;
};
template <typename U, typename T>
using ignore_t = typename ignore<U, T>::type;
 
template <typename T, typename F>
KBLIB_NODISCARD auto byte_cast(F v) noexcept -> T {
   static_assert(
       sizeof(T) == sizeof(F),
       "Source and destination types for byte_cast must be the same size.");
   static_assert(std::is_trivially_copyable<T>::value
                     and std::is_trivially_copyable<F>::value,
                 "Source and destination types for byte_cast must be trivially "
                 "copyable.");
   T ret{};
   std::memcpy(&ret, &v, sizeof(T));
   return ret;
}
 
namespace detail {
 
   template <typename C, typename = decltype(std::declval<C&>().resize(0))>
   auto calc_resizable(int) noexcept -> std::true_type;
 
   template <typename C, int = std::tuple_size<C>::value>
   auto calc_resizable(int) noexcept -> std::false_type;
 
   template <typename>
   auto calc_resizable(...) noexcept -> std::false_type;
 
} // namespace detail
 
// Note that when a type that is not resizable, but also doesn't have a
// constexpr size, is passed, there is a hard error.
template <typename C>
KBLIB_CONSTANT_V is_resizable_v = decltype(detail::calc_resizable<C>(0))::value;
 
template <typename C>
struct is_resizable : bool_constant<is_resizable_v<C>> {};
 
template <typename C, typename = void>
KBLIB_CONSTANT_V has_reserve_v = false;
 
template <typename C>
KBLIB_CONSTANT_V
    has_reserve_v<C, void_t<decltype(std::declval<C&>().reserve(0))>> = true;
 
template <typename C>
struct has_reserve : bool_constant<has_reserve_v<C>> {};
 
template <typename C, typename std::enable_if<has_reserve_v<C>, int>::type = 0>
auto try_reserve(C& c, std::size_t s) noexcept(noexcept(c.reserve(s))) -> void {
   c.reserve(s);
   return;
}
 
template <typename C,
          typename std::enable_if<not has_reserve_v<C>, int>::type = 0>
auto try_reserve(C&, std::size_t) noexcept -> void {
   return;
}
 
template <typename C, typename = void>
KBLIB_CONSTANT_V is_contiguous_v = false;
 
template <typename C>
KBLIB_CONSTANT_V
    is_contiguous_v<C, void_t<decltype(std::declval<C&>().data())>> = true;
 
template <typename C>
struct is_contiguous : bool_constant<is_contiguous_v<C>> {};
 
template <typename T>
struct class_of;
 
template <typename T, typename M>
struct class_of<M T::*> {
   using type = T;
};
 
template <typename T>
using class_of_t = typename class_of<T>::type;
 
#if __cpp_nontype_template_parameter_auto
 
template <auto M>
using class_t = typename class_of<decltype(M)>::type;
 
#endif
 
template <typename T>
struct member_of;
 
template <typename T, typename M>
struct member_of<M T::*> {
   using type = M;
};
 
template <typename T>
using member_of_t = typename member_of<T>::type;
 
#if __cpp_nontype_template_parameter_auto
template <typename, auto M>
using member_t = member_of_t<decltype(M)>;
#endif
 
template <typename F>
struct return_type;
 
template <typename R, typename... Args>
struct return_type<R(Args...)> : meta_type<R> {};
 
template <typename R, typename... Args>
struct return_type<R(Args...) const> : meta_type<R> {};
 
template <typename R, typename... Args>
struct return_type<R(Args...) volatile> : meta_type<R> {};
 
template <typename R, typename... Args>
struct return_type<R(Args...) const volatile> : meta_type<R> {};
 
template <typename T>
struct exists : std::true_type {};
 
template <typename T, typename = void>
struct is_input_iterator : std::false_type {};
 
template <typename T>
struct is_input_iterator<
    T, void_if_t<std::is_base_of<
           std::input_iterator_tag,
           typename std::iterator_traits<T>::iterator_category>::value>>
    : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_input_iterator_v = is_input_iterator<T>::value;
 
template <typename T, typename = void>
struct is_forward_iterator : std::false_type {};
 
template <typename T>
struct is_forward_iterator<
    T, void_if_t<std::is_base_of<
           std::forward_iterator_tag,
           typename std::iterator_traits<T>::iterator_category>::value>>
    : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_forward_iterator_v = is_forward_iterator<T>::value;
 
template <typename T, typename = void>
struct is_bidirectional_iterator : std::false_type {};
 
template <typename T>
struct is_bidirectional_iterator<
    T, void_if_t<std::is_base_of<
           std::bidirectional_iterator_tag,
           typename std::iterator_traits<T>::iterator_category>::value>>
    : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_bidirectional_iterator_v
    = is_bidirectional_iterator<T>::value;
 
template <typename T, typename = void>
struct is_random_access_iterator : std::false_type {};
 
template <typename T>
struct is_random_access_iterator<
    T, void_if_t<std::is_base_of<
           std::random_access_iterator_tag,
           typename std::iterator_traits<T>::iterator_category>::value>>
    : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_random_access_iterator_v
    = is_random_access_iterator<T>::value;
 
template <typename Range, typename = void>
struct iterator_type_for;
template <typename T, std::size_t N>
struct iterator_type_for<T[N], void> {
   using type = T*;
};
template <typename Range>
struct iterator_type_for<Range,
                         void_t<decltype(begin(std::declval<Range&>()))>> {
   using type = decltype(begin(std::declval<Range&>()));
};
 
template <typename Range>
using iterator_type_for_t = typename iterator_type_for<Range>::type;
 
template <typename Range, typename = void>
struct is_iterable : std::false_type {};
 
template <typename Range>
struct is_iterable<Range, void_if_t<is_input_iterator<decltype(
                              begin(std::declval<Range&>()))>::value>>
    : std::true_type {};
 
template <typename T, std::size_t N>
struct is_iterable<T[N], void> : std::true_type {};
template <typename T, std::size_t N>
struct is_iterable<T (&)[N], void> : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_iterable_v = is_iterable<T>::value;
 
template <typename T, typename = void>
struct is_iterator : std::false_type {};
 
template <typename T>
struct is_iterator<
    T, void_t<decltype(*std::declval<T&>(), void(), ++std::declval<T&>())>>
    : std::true_type {};
 
template <typename T>
KBLIB_CONSTANT_V is_iterator_v = is_iterator<T>::value;
 
template <typename T>
KBLIB_CONSTANT_V is_reference_v = std::is_reference<T>::value;
 
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
 
template <typename CharT = char>
KBLIB_CONSTANT auto eof = std::char_traits<CharT>::eof();
 
template <typename T, T V>
struct type_constant {
   constexpr operator T() const noexcept { return V; }
   static constexpr T value = V;
};
 
#if __cpp_nontype_template_parameter_auto
 
template <auto V>
using type_constant_for = type_constant<decltype(V), V>;
 
#endif
 
template <typename T>
struct is_aliasing_type : std::false_type {};
template <>
struct is_aliasing_type<char> : std::true_type {};
template <>
struct is_aliasing_type<unsigned char> : std::true_type {};
#if __cpp_lib_byte
template <>
struct is_aliasing_type<std::byte> : std::true_type {};
#endif
 
template <typename T>
KBLIB_CONSTANT_V is_aliasing_type_v = is_aliasing_type<T>::value;
 
} // namespace KBLIB_NS
 
#endif // KBLIB_TRAITS_H_INCLUDED_