meta.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/meta.hpp
/// @brief Metaprogramming, template variables and concepts
/// @ingroup userver_universal
 
#include <iosfwd>
#include <iterator>
#include <optional>
#include <type_traits>
#include <vector>
 
#include <userver/utils/meta_light.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace meta {
 
namespace impl {
 
using std::begin;
using std::end;
 
template <typename T>
using KeyType = typename T::key_type;
 
template <typename T>
using MappedType = typename T::mapped_type;
 
template <typename T>
using IsRange = ExpectSame<std::decay_t<decltype(begin(std::declval<T&>()))>,
                           std::decay_t<decltype(end(std::declval<T&>()))>>;
 
template <typename T>
using IteratorType = std::enable_if_t<kIsDetected<IsRange, T>,
                                      decltype(begin(std::declval<T&>()))>;
 
template <typename T, typename = void>
struct IsIterator : std::false_type {};
 
template <typename T>
struct IsIterator<
    T, std::void_t<typename std::iterator_traits<T>::iterator_category>>
    : std::true_type {};
 
template <typename T>
using RangeValueType =
    typename std::iterator_traits<DetectedType<IteratorType, T>>::value_type;
 
template <typename T>
using OstreamWriteResult =
    decltype(std::declval<std::ostream&>()
             << std::declval<const std::remove_reference_t<T>&>());
 
template <typename T, typename U>
using EqualityComparisonResult =
    decltype(std::declval<const T&>() == std::declval<const U&>());
 
template <typename T>
using StdHashResult = decltype(std::hash<T>{}(std::declval<const T&>()));
 
template <typename T>
using IsSizable = decltype(std::size(std::declval<T>()));
 
template <typename T>
using ReserveResult = decltype(std::declval<T&>().reserve(1));
 
template <typename T>
using AtResult =
    decltype(std::declval<const T&>().at(std::declval<typename T::key_type>()));
 
template <typename T>
using SubscriptOperatorResult =
    decltype(std::declval<T>()[std::declval<typename T::key_type>()]);
 
template <typename T>
using PushBackResult = decltype(std::declval<T&>().push_back({}));
 
template <typename T>
struct IsFixedSizeContainer : std::false_type {};
 
// Boost and std arrays
template <typename T, std::size_t Size,
          template <typename, std::size_t> typename Array>
struct IsFixedSizeContainer<Array<T, Size>>
    : std::bool_constant<sizeof(Array<T, Size>) == sizeof(T) * Size> {};
 
template <typename... Args>
constexpr bool IsSingleRange() {
  if constexpr (sizeof...(Args) == 1) {
    return kIsDetected<IsRange, Args...>;
  } else {
    return false;
  }
}
 
}  // namespace impl
 
template <typename T>
inline constexpr bool kIsVector = kIsInstantiationOf<std::vector, T>;
 
template <typename T>
inline constexpr bool kIsRange = kIsDetected<impl::IsRange, T>;
 
/// Returns true if T is an ordered or unordered map or multimap
template <typename T>
inline constexpr bool kIsMap =
    kIsDetected<impl::IsRange, T> && kIsDetected<impl::KeyType, T> &&
    kIsDetected<impl::MappedType, T>;
 
/// Returns true if T is a map (but not a multimap!)
template <typename T>
inline constexpr bool kIsUniqueMap =
    kIsMap<T> && kIsDetected<impl::SubscriptOperatorResult,
                             T>;  // no operator[] in multimaps
 
template <typename T>
using MapKeyType = DetectedType<impl::KeyType, T>;
 
template <typename T>
using MapValueType = DetectedType<impl::MappedType, T>;
 
template <typename T>
using RangeValueType = DetectedType<impl::RangeValueType, T>;
 
template <typename T>
inline constexpr bool kIsRecursiveRange =
    std::is_same_v<DetectedType<impl::RangeValueType, T>, T>;
 
template <typename T>
inline constexpr bool kIsIterator = impl::IsIterator<T>::value;
 
template <typename T>
inline constexpr bool kIsOptional = kIsInstantiationOf<std::optional, T>;
 
template <typename T>
inline constexpr bool kIsOstreamWritable =
    std::is_same_v<DetectedType<impl::OstreamWriteResult, T>, std::ostream&>;
 
template <typename T, typename U = T>
inline constexpr bool kIsEqualityComparable =
    std::is_same_v<DetectedType<impl::EqualityComparisonResult, T, U>, bool>;
 
template <typename T>
inline constexpr bool kIsStdHashable =
    std::is_same_v<DetectedType<impl::StdHashResult, T>, std::size_t> &&
    kIsEqualityComparable<T>;
 
/// @brief  Check if std::size is applicable to container
template <typename T>
inline constexpr bool kIsSizable = kIsDetected<impl::IsSizable, T>;
 
/// @brief Check if a container has `reserve`
template <typename T>
inline constexpr bool kIsReservable = kIsDetected<impl::ReserveResult, T>;
 
/// @brief Check if a container has 'push_back'
template <typename T>
inline constexpr bool kIsPushBackable = kIsDetected<impl::PushBackResult, T>;
 
/// @brief Check if a container has fixed size (e.g. std::array)
template <typename T>
inline constexpr bool kIsFixedSizeContainer =
    impl::IsFixedSizeContainer<T>::value;
 
/// @brief Returns default inserter for a container
template <typename T>
auto Inserter(T& container) {
  if constexpr (kIsPushBackable<T>) {
    return std::back_inserter(container);
  } else if constexpr (kIsFixedSizeContainer<T>) {
    return container.begin();
  } else {
    return std::inserter(container, container.end());
  }
}
 
}  // namespace meta
 
USERVER_NAMESPACE_END