typeTraits.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TYPETRAITS_HPP
#define RTCTK_COMPONENTFRAMEWORK_TYPETRAITS_HPP
 
#include <complex>
#include <gsl/span>
#include <utility>
#include <vector>
 
#include <rtctk/componentFramework/matrixBuffer.hpp>
#include <rtctk/componentFramework/matrixSpan.hpp>
 
namespace rtctk::componentFramework {
 
// The following are helper classes to identify certain type specialisations.

template <typename>
struct IsVectorType : std::false_type {};

template <typename T, typename A>
struct IsVectorType<std::vector<T, A>> : std::true_type {};

template <typename T>
inline constexpr bool IS_VECTOR_TYPE = IsVectorType<T>::value;
 
// tests
static_assert(IS_VECTOR_TYPE<std::array<uint8_t, 1>> == false);
static_assert(IS_VECTOR_TYPE<gsl::span<uint8_t>> == false);
static_assert(IS_VECTOR_TYPE<gsl::span<uint8_t, 3>> == false);
static_assert(IS_VECTOR_TYPE<std::vector<uint8_t>> == true);
static_assert(IS_VECTOR_TYPE<std::vector<uint8_t, std::allocator<std::byte>>> == true);
static_assert(IS_VECTOR_TYPE<uint8_t> == false);
static_assert(IS_VECTOR_TYPE<MatrixBuffer<uint8_t>> == false);

template <typename>
struct IsMatrixBufferType : std::false_type {};

template <typename T, typename A>
struct IsMatrixBufferType<MatrixBuffer<T, A>> : std::true_type {};

template <typename T>
inline constexpr bool IS_MATRIX_BUFFER_TYPE = IsMatrixBufferType<T>::value;
 
// tests
static_assert(IS_MATRIX_BUFFER_TYPE<std::array<uint8_t, 1>> == false);
static_assert(IS_MATRIX_BUFFER_TYPE<gsl::span<uint8_t>> == false);
static_assert(IS_MATRIX_BUFFER_TYPE<gsl::span<uint8_t, 3>> == false);
static_assert(IS_MATRIX_BUFFER_TYPE<std::vector<uint8_t>> == false);
static_assert(IS_MATRIX_BUFFER_TYPE<uint8_t> == false);
static_assert(IS_MATRIX_BUFFER_TYPE<MatrixBuffer<uint8_t>> == true);
static_assert(IS_MATRIX_BUFFER_TYPE<MatrixBuffer<uint8_t, std::allocator<std::byte>>> == true);

template <typename>
struct IsSpanType : std::false_type {};

template <typename T, decltype(gsl::dynamic_extent) N>
struct IsSpanType<gsl::span<T, N>> : std::true_type {};

template <typename T>
inline constexpr bool IS_SPAN_TYPE = IsSpanType<T>::value;

template <typename>
struct IsMatrixSpanType : std::false_type {};

template <typename T>
struct IsMatrixSpanType<MatrixSpan<T>> : std::true_type {};

template <typename T>
inline constexpr bool IS_MATRIX_SPAN_TYPE = IsMatrixSpanType<T>::value;

template <typename>
struct IsStdArrayType : std::false_type {};

template <typename T, std::size_t N>
struct IsStdArrayType<std::array<T, N>> : std::true_type {};

template <typename T>
inline constexpr bool IS_STD_ARRAY_TYPE = IsStdArrayType<T>::value;
 
// tests
static_assert(IS_STD_ARRAY_TYPE<std::array<uint8_t, 1>> == true);
static_assert(IS_STD_ARRAY_TYPE<gsl::span<uint8_t, 3>> == false);
static_assert(IS_STD_ARRAY_TYPE<gsl::span<uint8_t>> == false);
static_assert(IS_STD_ARRAY_TYPE<uint8_t> == false);
static_assert(IS_STD_ARRAY_TYPE<std::vector<uint8_t>> == false);
static_assert(IS_STD_ARRAY_TYPE<MatrixBuffer<uint8_t>> == false);

template <typename>
struct IsStaticSpanType : std::false_type {};

template <typename T, decltype(gsl::dynamic_extent) N>
struct IsStaticSpanType<gsl::span<T, N>>
    : std::conditional_t<N == gsl::dynamic_extent, std::false_type, std::true_type> {};

template <typename T>
inline constexpr bool IS_STATIC_SPAN_TYPE = IsStaticSpanType<T>::value;
 
// tests
static_assert(IS_STATIC_SPAN_TYPE<std::array<uint8_t, 1>> == false);
static_assert(IS_STATIC_SPAN_TYPE<gsl::span<uint8_t, 3>> == true);
static_assert(IS_STATIC_SPAN_TYPE<gsl::span<uint8_t>> == false);
static_assert(IS_STATIC_SPAN_TYPE<uint8_t> == false);
static_assert(IS_STATIC_SPAN_TYPE<std::vector<uint8_t>> == false);
static_assert(IS_STATIC_SPAN_TYPE<MatrixBuffer<uint8_t>> == false);

template <typename>
struct IsDynamicSpanType : std::false_type {};

template <typename T, decltype(gsl::dynamic_extent) N>
struct IsDynamicSpanType<gsl::span<T, N>>
    : std::conditional_t<N == gsl::dynamic_extent, std::true_type, std::false_type> {};

template <typename T>
inline constexpr bool IS_DYNAMIC_SPAN_TYPE = IsDynamicSpanType<T>::value;
 
// tests
static_assert(IS_DYNAMIC_SPAN_TYPE<std::array<uint8_t, 1>> == false);
static_assert(IS_DYNAMIC_SPAN_TYPE<gsl::span<uint8_t>> == true);
static_assert(IS_DYNAMIC_SPAN_TYPE<gsl::span<uint8_t, 3>> == false);
static_assert(IS_DYNAMIC_SPAN_TYPE<uint8_t> == false);
static_assert(IS_DYNAMIC_SPAN_TYPE<std::vector<uint8_t>> == false);
static_assert(IS_DYNAMIC_SPAN_TYPE<MatrixBuffer<uint8_t>> == false);

template <class, class = void>
struct IsSupportedUriSchemeDefined : std::false_type {};

template <class T>
struct IsSupportedUriSchemeDefined<T, std::void_t<decltype(T::SUPPORTED_URI_SCHEME)>>
    : std::true_type {};

template <typename T>
inline constexpr bool IS_SUPPORTED_URI_SCHEME_DEFINED = IsSupportedUriSchemeDefined<T>::value;

template <class, class = void>
struct IsAdapterIdTypeDefined : std::false_type {};

template <class T>
struct IsAdapterIdTypeDefined<T, std::void_t<decltype(std::declval<typename T::AdapterIdType>())>>
    : std::true_type {};

template <typename T>
inline constexpr bool IS_ADAPTER_ID_TYPE_DEFINED = IsAdapterIdTypeDefined<T>::value;

template <typename>
struct IsComplexType : std::false_type {};

template <typename T>
struct IsComplexType<std::complex<T>> : std::true_type {};

template <typename T>
inline constexpr bool IS_COMPLEX_TYPE = IsComplexType<T>::value;
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TYPETRAITS_HPP