traits.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <type_traits>
 
#include "trlc/platform/features.hpp"
 
namespace trlc {
namespace platform {
 
// =============================================================================
// Template Specializations for hasFeature
// =============================================================================
 
template <>
constexpr bool hasFeature<LanguageFeature::exceptions>() noexcept {
    return hasExceptions();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::rtti>() noexcept {
    return hasRtti();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::threads>() noexcept {
    return hasThreads();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::atomic_operations>() noexcept {
    return hasAtomicOperations();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::inline_assembly>() noexcept {
    return hasInlineAssembly();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::vector_intrinsics>() noexcept {
    return hasVectorIntrinsics();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::stack_protection>() noexcept {
    return hasStackProtection();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::address_sanitizer>() noexcept {
    return hasAddressSanitizer();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::thread_sanitizer>() noexcept {
    return hasThreadSanitizer();
}
 
template <>
constexpr bool hasFeature<LanguageFeature::memory_sanitizer>() noexcept {
    return hasMemorySanitizer();
}
 
// =============================================================================
// Runtime Feature Template Functions
// =============================================================================
 
template <RuntimeFeature TFeature>
bool hasRuntimeFeature() noexcept {
    return getFeatureSet().hasRuntimeFeature(TFeature);
}
 
// Specializations for common runtime features (for better optimization)
template <>
inline bool hasRuntimeFeature<RuntimeFeature::sse>() noexcept {
    return hasSseSupport();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::sse2>() noexcept {
    return hasSse2Support();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::sse3>() noexcept {
    return hasSse3Support();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::sse4_1>() noexcept {
    return hasSse41Support();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::sse4_2>() noexcept {
    return hasSse42Support();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::avx>() noexcept {
    return hasAvxSupport();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::avx2>() noexcept {
    return hasAvx2Support();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::avx512f>() noexcept {
    return hasAvx512fSupport();
}
 
template <>
inline bool hasRuntimeFeature<RuntimeFeature::neon>() noexcept {
    return hasNeonSupport();
}
 
namespace traits {
 
// =============================================================================
// C++17 Compatibility Helpers
// =============================================================================
 
#if __cplusplus >= 201703L
// C++17 has these in std
template <bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
 
template <bool B>
using bool_constant = std::integral_constant<bool, B>;
#else
// C++14 compatibility
template <bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
 
template <bool B>
using bool_constant = std::integral_constant<bool, B>;
#endif
 
// =============================================================================
// SFINAE Helpers for Template Constraints
// =============================================================================
 
template <LanguageFeature TFeature>
using enable_if_feature_t = enable_if_t<hasFeature<TFeature>()>;
 
template <LanguageFeature TFeature>
using enable_if_no_feature_t = enable_if_t<!hasFeature<TFeature>()>;
 
template <LanguageFeature... Features>
using enable_if_all_features_t = enable_if_t<(hasFeature<Features>() && ...)>;
 
template <LanguageFeature... Features>
using enable_if_any_feature_t = enable_if_t<(hasFeature<Features>() || ...)>;
 
// =============================================================================
// Variadic Template Functions for Multi-Feature Requirements
// =============================================================================
 
template <LanguageFeature... Features>
constexpr bool hasAllFeatures() noexcept {
    return (hasFeature<Features>() && ...);
}
 
template <LanguageFeature... Features>
constexpr bool hasAnyFeature() noexcept {
    return (hasFeature<Features>() || ...);
}
 
template <LanguageFeature... Features>
constexpr std::size_t countAvailableFeatures() noexcept {
    return (static_cast<std::size_t>(hasFeature<Features>()) + ...);
}
 
// =============================================================================
// Type Traits for Feature Detection
// =============================================================================
 
template <LanguageFeature TFeature>
struct FeatureAvailable : bool_constant<hasFeature<TFeature>()> {};
 
template <LanguageFeature TFeature>
constexpr bool feature_available_v = FeatureAvailable<TFeature>::value;
 
template <LanguageFeature... Features>
struct AllFeaturesAvailable : bool_constant<hasAllFeatures<Features...>()> {};
 
template <LanguageFeature... Features>
constexpr bool all_features_available_v = AllFeaturesAvailable<Features...>::value;
 
template <LanguageFeature... Features>
struct AnyFeatureAvailable : bool_constant<hasAnyFeature<Features...>()> {};
 
template <LanguageFeature... Features>
constexpr bool any_feature_available_v = AnyFeatureAvailable<Features...>::value;
 
// =============================================================================
// Runtime Feature Type Traits
// =============================================================================
 
template <RuntimeFeature TFeature>
struct RuntimeFeatureAvailable {
    static bool value() noexcept { return hasRuntimeFeature<TFeature>(); }
};
 
// =============================================================================
// Compile-Time Feature Constants
// =============================================================================
 
template <LanguageFeature TFeature>
constexpr bool getFeatureConstant() noexcept {
    return hasFeature<TFeature>();
}
 
template <LanguageFeature TFeature>
constexpr bool feature_constant_v = getFeatureConstant<TFeature>();
 
}  // namespace traits
}  // namespace platform
}  // namespace trlc
 
// =============================================================================
// Convenience Macros for Advanced Feature Testing
// =============================================================================
 
#define TRLC_HAS_LANGUAGE_FEATURE(feature) \
    (trlc::platform::hasFeature<trlc::platform::LanguageFeature::feature>())
 
#define TRLC_HAS_RUNTIME_FEATURE(feature) \
    (trlc::platform::hasRuntimeFeature<trlc::platform::RuntimeFeature::feature>())
 
#define TRLC_IF_LANGUAGE_FEATURE(feature) \
    if constexpr (trlc::platform::hasFeature<trlc::platform::LanguageFeature::feature>())
 
#define TRLC_IF_NO_LANGUAGE_FEATURE(feature) \
    if constexpr (!trlc::platform::hasFeature<trlc::platform::LanguageFeature::feature>())
 
#define TRLC_REQUIRE_FEATURE(feature)                                 \
    template <typename = trlc::platform::traits::enable_if_feature_t< \
                  trlc::platform::LanguageFeature::feature>>
 
#define TRLC_REQUIRE_NO_FEATURE(feature)                                 \
    template <typename = trlc::platform::traits::enable_if_no_feature_t< \
                  trlc::platform::LanguageFeature::feature>>
 
#define TRLC_HAS_ALL_FEATURES(...) (trlc::platform::traits::hasAllFeatures<__VA_ARGS__>())
 
#define TRLC_HAS_ANY_FEATURES(...) (trlc::platform::traits::hasAnyFeature<__VA_ARGS__>())