platform.hpp

Go to the documentation of this file.

#pragma once
 
namespace trlc {
namespace platform {
 
enum class OperatingSystem : int {
    unknown = 0,    
    windows,        
    linux_generic,  
    ubuntu,         
    debian,         
    redhat,         
    macos,          
    freebsd,        
    openbsd,        
    netbsd,         
    android,        
    ios             
};
 
enum class EnvironmentType : int {
    unknown = 0,  
    desktop,      
    server,       
    embedded,     
    mobile        
};
 
struct PlatformInfo {
    OperatingSystem os;           
    EnvironmentType environment;  
    const char* os_name;          
    const char* kernel_family;    
 
    constexpr bool isPosix() const noexcept {
        return (kernel_family[0] == 'p' && kernel_family[1] == 'o') ||  // "posix"
               (kernel_family[0] == 'u' && kernel_family[1] == 'n');    // "unix"
    }
 
    constexpr bool isUnix() const noexcept {
        return os == OperatingSystem::linux_generic || os == OperatingSystem::ubuntu ||
               os == OperatingSystem::debian || os == OperatingSystem::redhat ||
               os == OperatingSystem::macos || os == OperatingSystem::freebsd ||
               os == OperatingSystem::openbsd || os == OperatingSystem::netbsd ||
               os == OperatingSystem::android;
    }
 
    constexpr bool isWindows() const noexcept { return os == OperatingSystem::windows; }
};
 
constexpr OperatingSystem getOperatingSystem() noexcept {
// Check for Android first (it defines __linux__ but is not generic Linux)
#if defined(__ANDROID__)
    return OperatingSystem::android;
// Check for iOS
#elif defined(__APPLE__) && defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
    return OperatingSystem::ios;
// Check for macOS
#elif defined(__APPLE__) && defined(__MACH__)
    return OperatingSystem::macos;
// Check for Windows
#elif defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
    return OperatingSystem::windows;
// Check for specific BSD variants
#elif defined(__FreeBSD__)
    return OperatingSystem::freebsd;
#elif defined(__OpenBSD__)
    return OperatingSystem::openbsd;
#elif defined(__NetBSD__)
    return OperatingSystem::netbsd;
// Check for Linux distributions
#elif defined(__linux__) || defined(__gnu_linux__)
    // For now, return generic Linux
    // In a real implementation, we might read /etc/os-release at runtime
    // or use additional compile-time detection methods
    return OperatingSystem::linux_generic;
#else
    return OperatingSystem::unknown;
#endif
}
 
constexpr EnvironmentType getEnvironmentType() noexcept {
    constexpr auto os = getOperatingSystem();
 
    // Mobile platforms
    if (os == OperatingSystem::android || os == OperatingSystem::ios) {
        return EnvironmentType::mobile;
    }
 
    // Desktop platforms
    if (os == OperatingSystem::windows || os == OperatingSystem::macos) {
        return EnvironmentType::desktop;
    }
 
    // Unix-like systems - typically server environments
    if (os == OperatingSystem::linux_generic || os == OperatingSystem::ubuntu ||
        os == OperatingSystem::debian || os == OperatingSystem::redhat ||
        os == OperatingSystem::freebsd || os == OperatingSystem::openbsd ||
        os == OperatingSystem::netbsd) {
        // Default to server for Unix-like systems
        // In practice, this might be refined based on additional detection
        return EnvironmentType::server;
    }
 
    return EnvironmentType::unknown;
}
 
constexpr PlatformInfo getPlatformInfo() noexcept {
    constexpr auto os = getOperatingSystem();
    constexpr auto env = getEnvironmentType();
 
    // Determine OS name and kernel family based on detected OS
    const char* os_name = nullptr;
    const char* kernel_family = nullptr;
 
    switch (os) {
        case OperatingSystem::windows:
            os_name = "Windows";
            kernel_family = "nt";
            break;
        case OperatingSystem::linux_generic:
            os_name = "Linux";
            kernel_family = "posix";
            break;
        case OperatingSystem::ubuntu:
            os_name = "Ubuntu";
            kernel_family = "posix";
            break;
        case OperatingSystem::debian:
            os_name = "Debian";
            kernel_family = "posix";
            break;
        case OperatingSystem::redhat:
            os_name = "Red Hat";
            kernel_family = "posix";
            break;
        case OperatingSystem::macos:
            os_name = "macOS";
            kernel_family = "unix";
            break;
        case OperatingSystem::freebsd:
            os_name = "FreeBSD";
            kernel_family = "unix";
            break;
        case OperatingSystem::openbsd:
            os_name = "OpenBSD";
            kernel_family = "unix";
            break;
        case OperatingSystem::netbsd:
            os_name = "NetBSD";
            kernel_family = "unix";
            break;
        case OperatingSystem::android:
            os_name = "Android";
            kernel_family = "posix";
            break;
        case OperatingSystem::ios:
            os_name = "iOS";
            kernel_family = "unix";
            break;
        case OperatingSystem::unknown:
        default:
            os_name = "Unknown";
            kernel_family = "unknown";
            break;
    }
 
    return PlatformInfo{os, env, os_name, kernel_family};
}
 
constexpr bool hasPosixApi() noexcept {
// Check for POSIX version macro
#if defined(_POSIX_VERSION)
    return true;
// Check for common Unix/POSIX indicators
#elif defined(__unix__) || defined(__unix) || defined(unix)
    return true;
// Platform-specific checks
#elif defined(__linux__) || defined(__gnu_linux__)
    return true;
#elif defined(__APPLE__) && defined(__MACH__)
    return true;
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
    return true;
#elif defined(__ANDROID__)
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasWin32Api() noexcept {
#if defined(_WIN32) || defined(_WIN64)
    return true;
#elif defined(__CYGWIN__)
    return true;  // Cygwin provides Win32 API access
#else
    return false;
#endif
}
 
constexpr bool supportsCaseSensitiveFilesystem() noexcept {
    constexpr auto os = getOperatingSystem();
 
    // Unix-like systems typically have case-sensitive filesystems
    if (os == OperatingSystem::linux_generic || os == OperatingSystem::ubuntu ||
        os == OperatingSystem::debian || os == OperatingSystem::redhat ||
        os == OperatingSystem::freebsd || os == OperatingSystem::openbsd ||
        os == OperatingSystem::netbsd || os == OperatingSystem::android) {
        return true;
    }
 
    // Windows and macOS typically have case-insensitive filesystems by default
    // (though they can be configured to be case-sensitive)
    if (os == OperatingSystem::windows || os == OperatingSystem::macos ||
        os == OperatingSystem::ios) {
        return false;
    }
 
    // Default to case-sensitive for unknown platforms
    return true;
}
 
}  // namespace platform
}  // namespace trlc
 
// Convenience macros for conditional compilation
 
#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
    #define TRLC_PLATFORM_WINDOWS 1
#else
    #define TRLC_PLATFORM_WINDOWS 0
#endif
 
#if defined(__linux__) || defined(__gnu_linux__)
    #define TRLC_PLATFORM_LINUX 1
#else
    #define TRLC_PLATFORM_LINUX 0
#endif
 
#if defined(__APPLE__) && defined(__MACH__) && !defined(TARGET_OS_IPHONE)
    #define TRLC_PLATFORM_MACOS 1
#else
    #define TRLC_PLATFORM_MACOS 0
#endif
 
#if defined(_POSIX_VERSION) || defined(__unix__) || defined(__unix) || defined(unix) ||          \
    defined(__linux__) || defined(__gnu_linux__) || (defined(__APPLE__) && defined(__MACH__)) || \
    defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__ANDROID__)
    #define TRLC_PLATFORM_POSIX 1
#else
    #define TRLC_PLATFORM_POSIX 0
#endif
 
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || \
    (defined(__APPLE__) && defined(__MACH__))
    #define TRLC_PLATFORM_BSD 1
#else
    #define TRLC_PLATFORM_BSD 0
#endif
 
#if TRLC_PLATFORM_LINUX || TRLC_PLATFORM_MACOS || TRLC_PLATFORM_BSD || defined(__ANDROID__)
    #define TRLC_PLATFORM_UNIX 1
#else
    #define TRLC_PLATFORM_UNIX 0
#endif
 
#if defined(__ANDROID__) || (defined(__APPLE__) && defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
    #define TRLC_PLATFORM_MOBILE 1
#else
    #define TRLC_PLATFORM_MOBILE 0
#endif
 
#if TRLC_PLATFORM_UNIX && !TRLC_PLATFORM_MACOS
    #define TRLC_PLATFORM_CASE_SENSITIVE_FS 1
#else
    #define TRLC_PLATFORM_CASE_SENSITIVE_FS 0
#endif