core.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <iostream>
#include <sstream>
#include <string>
#include <thread>  // For std::this_thread::yield
#include <type_traits>
 
// Include all platform detection headers in dependency order
#include "trlc/platform/architecture.hpp"
#include "trlc/platform/compiler.hpp"
#include "trlc/platform/cpp_standard.hpp"
#include "trlc/platform/endianness.hpp"
#include "trlc/platform/features.hpp"
#include "trlc/platform/macros.hpp"
#include "trlc/platform/platform.hpp"
#include "trlc/platform/typeinfo.hpp"
 
// Conditionally include debug utilities
#ifdef TRLC_PLATFORM_ENABLE_DEBUG_UTILS
    #include "trlc/platform/debug.hpp"
#endif
 
namespace trlc {
namespace platform {
 
//==============================================================================
// Version Information
//==============================================================================
 
struct Version {
    static constexpr int MAJOR = 1;
 
    static constexpr int MINOR = 0;
 
    static constexpr int PATCH = 0;
 
    static constexpr const char* STRING = "1.0.0";
 
    static constexpr uint32_t asInteger() noexcept {
        return (static_cast<uint32_t>(MAJOR) << 16) | (static_cast<uint32_t>(MINOR) << 8) |
               static_cast<uint32_t>(PATCH);
    }
 
    static constexpr bool isAtLeast(int major, int minor = 0, int patch = 0) noexcept {
        uint32_t current = asInteger();
        uint32_t required = (static_cast<uint32_t>(major) << 16) |
                            (static_cast<uint32_t>(minor) << 8) | static_cast<uint32_t>(patch);
        return current >= required;
    }
};
 
//==============================================================================
// Consolidated Platform Report
//==============================================================================
 
struct PlatformReport {
    CompilerInfo compiler;
 
    PlatformInfo platform;
 
    ArchitectureInfo architecture;
 
    CppStandardInfo cpp_standard;
 
    FeatureSet features;
 
    EndiannessInfo endianness;
 
    std::string generateReport() const {
        std::stringstream ss;
 
        ss << "TRLC Platform Detection Report v" << Version::STRING << "\n";
        ss << std::string(60, '=') << "\n\n";
 
        // Compiler Information
        ss << "COMPILER INFORMATION:\n";
        ss << std::string(25, '-') << "\n";
        ss << "  Type:                " << compiler.name << "\n";
        ss << "  Version:             " << compiler.version.major << "." << compiler.version.minor
           << "." << compiler.version.patch << "\n";
        ss << "  Builtin Attributes:  " << (compiler.has_builtin_attribute ? "Yes" : "No") << "\n";
        ss << "  Inline Assembly:     " << (compiler.has_inline_assembly ? "Yes" : "No") << "\n";
        ss << "  Color Diagnostics:   " << (compiler.has_color_diagnostics ? "Yes" : "No") << "\n";
        ss << "  GCC Compatible:      " << (compiler.isGccCompatible() ? "Yes" : "No") << "\n";
        ss << "  Clang Compatible:    " << (compiler.isClangCompatible() ? "Yes" : "No") << "\n\n";
 
        // Platform Information
        ss << "PLATFORM INFORMATION:\n";
        ss << std::string(25, '-') << "\n";
        ss << "  Operating System:    " << platform.os_name << "\n";
        ss << "  Kernel Family:       " << platform.kernel_family << "\n";
        ss << "  Environment Type:    ";
        switch (platform.environment) {
            case EnvironmentType::desktop:
                ss << "Desktop";
                break;
            case EnvironmentType::server:
                ss << "Server";
                break;
            case EnvironmentType::embedded:
                ss << "Embedded";
                break;
            case EnvironmentType::mobile:
                ss << "Mobile";
                break;
            default:
                ss << "Unknown";
                break;
        }
        ss << "\n";
        ss << "  POSIX API:           " << (platform.isPosix() ? "Yes" : "No") << "\n";
        ss << "  Windows API:         " << (platform.isWindows() ? "Yes" : "No") << "\n";
        ss << "  Case Sensitive FS:   " << (supportsCaseSensitiveFilesystem() ? "Yes" : "No")
           << "\n\n";
 
        // Architecture Information
        ss << "ARCHITECTURE INFORMATION:\n";
        ss << std::string(29, '-') << "\n";
        ss << "  CPU Architecture:    " << architecture.arch_name << "\n";
        ss << "  Pointer Size:        " << architecture.pointer_size_bits << " bits\n";
        ss << "  Byte Order:          ";
        switch (architecture.byte_order) {
            case ByteOrder::little_endian:
                ss << "Little Endian";
                break;
            case ByteOrder::big_endian:
                ss << "Big Endian";
                break;
            case ByteOrder::mixed_endian:
                ss << "Mixed Endian";
                break;
            default:
                ss << "Unknown";
                break;
        }
        ss << "\n";
        ss << "  Cache Line Size:     " << architecture.cache_line_size << " bytes\n";
        ss << "  Unaligned Access:    " << (architecture.supportsUnalignedAccess() ? "Yes" : "No")
           << "\n";
        ss << "  SIMD Support:        " << (hasSimdSupport() ? "Yes" : "No") << "\n\n";
 
        // C++ Standard Information
        ss << "C++ STANDARD INFORMATION:\n";
        ss << std::string(29, '-') << "\n";
        ss << "  Standard Version:    " << cpp_standard.standard_name << "\n";
        ss << "  Version Macro:       " << cpp_standard.version_macro << "\n";
        ss << "  Structured Bindings: " << (hasStructuredBindings() ? "Yes" : "No") << "\n";
        ss << "  If Constexpr:        " << (hasIfConstexpr() ? "Yes" : "No") << "\n";
        ss << "  Concepts:            " << (hasConcepts() ? "Yes" : "No") << "\n";
        ss << "  Coroutines:          " << (hasCoroutines() ? "Yes" : "No") << "\n";
        ss << "  Modules:             " << (hasModules() ? "Yes" : "No") << "\n";
        ss << "  Ranges:              " << (hasRanges() ? "Yes" : "No") << "\n\n";
 
        // Feature Information
        ss << "FEATURE AVAILABILITY:\n";
        ss << std::string(25, '-') << "\n";
        ss << "  Exceptions:          " << (features.has_exceptions ? "Yes" : "No") << "\n";
        ss << "  RTTI:                " << (features.has_rtti ? "Yes" : "No") << "\n";
        ss << "  Threads:             " << (features.has_threads ? "Yes" : "No") << "\n";
        ss << "  Atomic Operations:   " << (features.has_atomic ? "Yes" : "No") << "\n";
        ss << "  Inline Assembly:     " << (features.has_inline_asm ? "Yes" : "No") << "\n";
        ss << "  SSE Support:         " << (features.has_sse ? "Yes" : "No") << "\n";
        ss << "  AVX Support:         " << (features.has_avx ? "Yes" : "No") << "\n";
        ss << "  NEON Support:        " << (features.has_neon ? "Yes" : "No") << "\n\n";
 
        // Endianness Information (using data from ArchitectureInfo)
        ss << "ENDIANNESS INFORMATION:\n";
        ss << std::string(27, '-') << "\n";
        ss << "  Byte Order:          ";
        switch (architecture.byte_order) {
            case ByteOrder::little_endian:
                ss << "Little Endian";
                break;
            case ByteOrder::big_endian:
                ss << "Big Endian";
                break;
            case ByteOrder::mixed_endian:
                ss << "Mixed Endian";
                break;
            default:
                ss << "Unknown";
                break;
        }
        ss << "\n";
        ss << "  Little Endian:       " << (architecture.isLittleEndian() ? "Yes" : "No") << "\n";
        ss << "  Big Endian:          "
           << (!architecture.isLittleEndian() && architecture.byte_order == ByteOrder::big_endian
                   ? "Yes"
                   : "No")
           << "\n\n";
 
        // Debug Information (if available)
#ifdef TRLC_PLATFORM_ENABLE_DEBUG_UTILS
        ss << "DEBUG INFORMATION:\n";
        ss << std::string(22, '-') << "\n";
        ss << "  Debug Build:         " << (isDebugBuild() ? "Yes" : "No") << "\n";
        ss << "  Release Build:       " << (isReleaseBuild() ? "Yes" : "No") << "\n";
        ss << "  Debug Info:          " << (hasDebugInfo() ? "Yes" : "No") << "\n";
        ss << "  Stack Trace:         " << (DebugUtils::canCaptureStackTrace() ? "Yes" : "No")
           << "\n\n";
#endif
 
        ss << std::string(60, '=') << "\n";
        ss << "Report generated by TRLC Platform v" << Version::STRING << "\n";
 
        return ss.str();
    }
 
    void printReport() const { std::cout << generateReport() << std::endl; }
 
    std::string getBriefSummary() const {
        std::stringstream ss;
        ss << compiler.name << " " << compiler.version.major << "." << compiler.version.minor
           << " on " << platform.os_name << " " << architecture.arch_name << " ("
           << architecture.pointer_size_bits << "-bit)";
        return ss.str();
    }
};
 
//==============================================================================
// Core Platform Detection Function
//==============================================================================
 
inline PlatformReport getPlatformReport() noexcept {
    return PlatformReport{
        getCompilerInfo(),
        getPlatformInfo(),
        getArchitectureInfo(),
        getCppStandardInfo(),
        getFeatureSet(),
        getEndiannessInfo()  // Now available from endianness.hpp
    };
}
 
//==============================================================================
// Runtime Feature Initialization
//==============================================================================
 
namespace detail {
inline std::atomic<bool> g_platform_initialized{false};
inline std::atomic<bool> g_initialization_in_progress{false};
}  // namespace detail
 
inline void initializePlatform() noexcept {
    // Check if already initialized
    if (detail::g_platform_initialized.load(std::memory_order_acquire)) {
        return;
    }
 
    // Check if initialization is in progress (prevent recursive calls)
    bool expected = false;
    if (!detail::g_initialization_in_progress.compare_exchange_strong(
            expected, true, std::memory_order_acq_rel)) {
        // Another thread is initializing, wait for completion
        while (!detail::g_platform_initialized.load(std::memory_order_acquire)) {
            // Use standard thread yield instead of platform-specific intrinsics
            std::this_thread::yield();
        }
        return;
    }
 
    try {
        // Perform runtime feature detection initialization
        // Most features are compile-time, but some CPU features need runtime detection
 
        // Initialize any runtime feature detection here
        // For now, most features are compile-time detected
 
        // Mark initialization complete
        detail::g_platform_initialized.store(true, std::memory_order_release);
 
    } catch (...) {
        // If initialization fails, reset the in-progress flag
        detail::g_initialization_in_progress.store(false, std::memory_order_release);
        // Don't propagate exceptions from initialization
        return;
    }
 
    // Clear the in-progress flag
    detail::g_initialization_in_progress.store(false, std::memory_order_release);
}
 
inline bool isPlatformInitialized() noexcept {
    return detail::g_platform_initialized.load(std::memory_order_acquire);
}
 
//==============================================================================
// Convenience Functions
//==============================================================================
 
inline std::string getBriefPlatformSummary() {
    auto report = getPlatformReport();
    return report.getBriefSummary();
}
 
inline void printPlatformReport() {
    auto report = getPlatformReport();
    report.printReport();
}
 
}  // namespace platform
}  // namespace trlc
 
//==============================================================================
// Master Include Guard and Compatibility Macros
//==============================================================================
 
#define TRLC_PLATFORM_INCLUDED
 
#define TRLC_PLATFORM_VERSION_MAJOR (trlc::platform::Version::MAJOR)
#define TRLC_PLATFORM_VERSION_MINOR (trlc::platform::Version::MINOR)
#define TRLC_PLATFORM_VERSION_PATCH (trlc::platform::Version::PATCH)
#define TRLC_PLATFORM_VERSION_STRING (trlc::platform::Version::STRING)
 
#define TRLC_PLATFORM_VERSION_ATLEAST(major, minor, patch) \
    (trlc::platform::Version::isAtLeast(major, minor, patch))
 
//==============================================================================
// Compile-Time Validation
//==============================================================================
 
// Verify that all required modules are available
static_assert(std::is_default_constructible_v<trlc::platform::CompilerInfo>,
              "CompilerInfo must be default constructible");
static_assert(std::is_default_constructible_v<trlc::platform::PlatformInfo>,
              "PlatformInfo must be default constructible");
static_assert(std::is_default_constructible_v<trlc::platform::ArchitectureInfo>,
              "ArchitectureInfo must be default constructible");
static_assert(std::is_default_constructible_v<trlc::platform::CppStandardInfo>,
              "CppStandardInfo must be default constructible");
static_assert(std::is_default_constructible_v<trlc::platform::FeatureSet>,
              "FeatureSet must be default constructible");
 
// Verify version information
static_assert(trlc::platform::Version::MAJOR >= 1, "Library major version must be at least 1");
static_assert(trlc::platform::Version::isAtLeast(1, 0, 0),
              "Version comparison must work correctly");
 
// Verify that the PlatformReport can be created
static_assert(std::is_default_constructible_v<trlc::platform::PlatformReport>,
              "PlatformReport must be constructible");
 
//==============================================================================
// Documentation Examples and Usage Notes
//==============================================================================
 
/*
Example Usage:
 
1. Basic platform detection:
   #include "trlc/platform/core.hpp"
 
   constexpr auto platform = trlc::platform::getPlatformReport();
   if constexpr (platform.compiler.type == trlc::platform::CompilerType::gcc) {
       // GCC-specific code
   }
 
2. Runtime initialization for CPU features:
   #include "trlc/platform/core.hpp"
 
   int main() {
       trlc::platform::initializePlatform();
 
       if (trlc::platform::hasAvxSupport()) {
           // Use AVX optimizations
       }
   }
 
3. Platform reporting:
   #include "trlc/platform/core.hpp"
 
   void logPlatformInfo() {
       auto report = trlc::platform::getPlatformReport();
       std::cout << report.generateReport() << std::endl;
   }
 
4. Brief platform summary:
   #include "trlc/platform/core.hpp"
 
   std::string getPlatformSummary() {
       return trlc::platform::getBriefPlatformSummary();
   }
 
5. Conditional compilation based on platform:
   #include "trlc/platform/core.hpp"
 
   void optimizedFunction() {
       constexpr auto platform = trlc::platform::getPlatformReport();
 
       if constexpr (platform.architecture.is64Bit() &&
                     platform.features.has_sse) {
           // 64-bit SSE optimized path
       } else {
           // Generic fallback
       }
   }
 
Thread Safety:
- All compile-time detection is inherently thread-safe
- Runtime initialization is thread-safe and idempotent
- Platform report generation is thread-safe
- Multiple threads can safely call all functions concurrently
 
Performance:
- Compile-time detection has zero runtime overhead
- Runtime initialization has minimal one-time cost
- Report generation has moderate cost (string formatting)
- Brief summaries are lightweight for frequent use
 
Integration:
- Header-only design requires no separate compilation
- All dependencies are standard library or self-contained
- Can be included in any C++17 or later project
- Works with all major compilers and platforms
*/