traits.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2024-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_TRAITS_H_
#define SRC_INCLUDE_SMASH_TRAITS_H_
 
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
#include "stringify.h"
 
namespace smash {
 
namespace detail {
 
template <typename T>
struct is_stl_container : std::false_type {};
 
template <typename... Args>
struct is_stl_container<std::vector<Args...>> : std::true_type {};
 
template <typename... Args>
struct is_stl_container<std::set<Args...>> : std::true_type {};
 
template <typename... Args>
struct is_stl_container<std::map<Args...>> : std::true_type {};
 
}  // namespace detail
 
//============================================================================//
template <typename T>
struct is_stl_container
    : std::bool_constant<detail::is_stl_container<std::decay_t<T>>::value> {};
 
template <typename T>
inline constexpr bool is_stl_container_v = is_stl_container<T>::value;
 
//============================================================================//
template <typename T, typename Enable = void>
struct is_tuple_like : std::false_type {};
 
template <typename T>
struct is_tuple_like<T, std::void_t<decltype(std::tuple_size<T>::value)>>
    : std::true_type {};
 
template <typename T>
inline constexpr bool is_tuple_like_v = is_tuple_like<T>::value;
 
//============================================================================//
template <typename T>
struct is_map_like : std::false_type {};
 
template <typename K, typename V, typename... Args>
struct is_map_like<std::map<K, V, Args...>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_map_like_v = is_map_like<std::decay_t<T>>::value;
 
//============================================================================//
template <typename S, typename T, typename Enable = void>
struct is_streamable : std::false_type {};
 
template <typename S, typename T>
struct is_streamable<
    S, T, std::void_t<decltype(std::declval<S&>() << std::declval<T>())>>
    : std::true_type {};
 
template <typename S, typename T>
inline constexpr bool is_streamable_v = is_streamable<S, T>::value;
 
//============================================================================//
template <typename S, typename T, typename Enable = void>
struct is_writable_to_stream : std::false_type {};
 
template <typename S, typename T>
struct is_writable_to_stream<
    S, T, std::enable_if_t<!is_stl_container_v<T> && !is_tuple_like_v<T>>>
    : std::bool_constant<is_streamable_v<S, T>> {};
 
template <typename S, typename T>
struct is_writable_to_stream<
    S, T, std::enable_if_t<is_stl_container_v<T> && !is_map_like_v<T>>>
    : std::bool_constant<
          is_streamable_v<S, T> &&
          is_writable_to_stream<S, typename T::value_type>::value> {};
 
template <typename S, typename T>
struct is_writable_to_stream<S, T, std::enable_if_t<is_map_like_v<T>>> {
 private:
  using key_type = typename T::key_type;
  using mapped_type = typename T::mapped_type;
 
 public:
  static constexpr bool value = is_streamable_v<S, T> &&
                                is_writable_to_stream<S, key_type>::value &&
                                is_writable_to_stream<S, mapped_type>::value;
};
 
template <typename S, typename T>
struct is_writable_to_stream<S, T, std::enable_if_t<is_tuple_like_v<T>>> {
 private:
  template <std::size_t... I>
  static constexpr bool check(std::index_sequence<I...>) {
    return (is_writable_to_stream<S, std::tuple_element_t<I, T>>::value && ...);
  }
 
 public:
  static constexpr bool value =
      is_streamable_v<S, T> &&
      check(std::make_index_sequence<std::tuple_size_v<T>>{});
};
 
template <typename S, typename T>
inline constexpr bool is_writable_to_stream_v =
    is_writable_to_stream<S, T>::value;
 
template <typename T, typename Enable = void>
struct has_to_string : std::false_type {};
 
template <typename T>
struct has_to_string<T,
                     std::void_t<decltype(smash::to_string(std::declval<T>()))>>
    : std::is_same<decltype(smash::to_string(std::declval<T>())), std::string> {
};
 
template <std::size_t N>
struct has_to_string<std::bitset<N>, std::void_t<decltype(smash::to_string(
                                         std::declval<std::bitset<N>>()))>>
    : std::is_same<decltype(smash::to_string(std::declval<std::bitset<N>>())),
                   std::vector<std::string>> {};
 
template <typename T>
inline constexpr bool has_to_string_v = has_to_string<T>::value;
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_TRAITS_H_