result_types.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/network/detail/config/feature_flags.h>
 
#if KCENON_WITH_COMMON_SYSTEM
    #include <kcenon/common/patterns/result.h>
    #include <kcenon/common/error/error_codes.h>
#endif
 
#include <variant>
#include <string>
 
namespace kcenon::network {
 
#if KCENON_WITH_COMMON_SYSTEM
    // ============================================================
    // Use common::Result<T> directly for new code
    // ============================================================
    //
    // network_system uses common_system's Result<T> as the primary
    // error handling mechanism. New code should use kcenon::common::Result<T>
    // directly for ecosystem-wide consistency.
    //
    // The type aliases (network::Result<T>, network::VoidResult,
    // network::error_info) are provided for internal use and backward
    // compatibility but are deprecated for external use.
    //
    // Migration path for external code:
    //   - kcenon::network::Result<T> -> kcenon::common::Result<T>
    //   - kcenon::network::VoidResult -> kcenon::common::VoidResult
    //   - kcenon::network::error_info -> kcenon::common::error_info
    //
    // See: https://github.com/kcenon/network_system/issues/494
    // ============================================================
 
    // Type aliases for internal use (deprecated for external use)
    // These map directly to common_system types
    template<typename T>
    using Result = ::kcenon::common::Result<T>;
    using VoidResult = ::kcenon::common::VoidResult;
    using error_info = ::kcenon::common::error_info;
 
namespace internal {
    // Internal type aliases - same as namespace-level types
    // Provided for explicit internal-only usage pattern
    template<typename T>
    using Result = ::kcenon::common::Result<T>;
    using VoidResult = ::kcenon::common::VoidResult;
    using error_info = ::kcenon::common::error_info;
} // namespace internal
 
    // Error code namespace (includes common_errors and network_system)
    namespace error_codes = ::kcenon::common::error::codes;
 
    // Extended error codes not yet in common_system
    namespace error_codes_ext {
        namespace network_system {
            constexpr int circuit_open = -604; 
        }
    }
 
    // Helper functions for creating Results
    template<typename T>
    inline Result<T> ok(T&& value) {
        return Result<T>(std::forward<T>(value));
    }
 
    inline VoidResult ok() {
        return VoidResult(std::monostate{});
    }
 
    template<typename T>
    inline Result<T> error(int code, const std::string& message,
                          const std::string& source = "network_system",
                          const std::string& details = "") {
        return Result<T>(error_info(code, message, source, details));
    }
 
    inline VoidResult error_void(int code, const std::string& message,
                                const std::string& source = "network_system",
                                const std::string& details = "") {
        return VoidResult(error_info(code, message, source, details));
    }
 
    // Helper to extract details string from error_info (handles optional<string>)
    inline std::string get_error_details(const error_info& err) {
        return err.details.value_or("");
    }
 
    // Helper to extract source/module string from error_info
    inline const std::string& get_error_source(const error_info& err) {
        return err.module;
    }
 
#else
    // Fallback: Simple Result<T> implementation when common_system is not available
    // This maintains API compatibility but with minimal error information
 
    struct simple_error {
        int code;
        std::string message;
        std::string source;
        std::string details;
 
        simple_error(int c, std::string msg, std::string src = "", std::string det = "")
            : code(c), message(std::move(msg)), source(std::move(src)), details(std::move(det)) {}
    };
 
    template<typename T>
    class Result {
    public:
        Result(const T& val) : data_(val) {}
        Result(T&& val) : data_(std::forward<T>(val)) {}
        Result(const simple_error& err) : data_(err) {}
 
        // Static factory methods for API compatibility with common::Result<T>
        template<typename U = T>
        static Result<T> ok(U&& value) {
            return Result<T>(std::forward<U>(value));
        }
 
        static Result<T> err(const simple_error& error) {
            return Result<T>(error);
        }
 
        static Result<T> err(int code, const std::string& message, const std::string& source = "") {
            return Result<T>(simple_error(code, message, source));
        }
 
        bool is_ok() const { return std::holds_alternative<T>(data_); }
        bool is_err() const { return !is_ok(); }
 
        const T& value() const { return std::get<T>(data_); }
        T& value() { return std::get<T>(data_); }
 
        const simple_error& error() const { return std::get<simple_error>(data_); }
 
        operator bool() const { return is_ok(); }
 
    private:
        std::variant<T, simple_error> data_;
    };
 
    using VoidResult = Result<std::monostate>;
    using error_info = simple_error;
 
namespace internal {
    // Internal type aliases for network_system implementation
    // These provide a consistent interface regardless of common_system availability
    template<typename T>
    using Result = ::kcenon::network::Result<T>;
    using VoidResult = ::kcenon::network::VoidResult;
    using error_info = ::kcenon::network::error_info;
} // namespace internal
 
    // Minimal error codes (fallback)
    namespace error_codes {
        namespace network_system {
            constexpr int connection_failed = -600;
            constexpr int connection_refused = -601;
            constexpr int connection_timeout = -602;
            constexpr int connection_closed = -603;
            constexpr int circuit_open = -604;
            constexpr int send_failed = -640;
            constexpr int receive_failed = -641;
            constexpr int server_not_started = -660;
            constexpr int server_already_running = -661;
            constexpr int bind_failed = -662;
        }
        namespace common_errors {
            constexpr int success = 0;
            constexpr int invalid_argument = -1;
            constexpr int not_found = -2;
            constexpr int permission_denied = -3;
            constexpr int timeout = -4;
            constexpr int cancelled = -5;
            constexpr int not_initialized = -6;
            constexpr int already_exists = -7;
            constexpr int out_of_memory = -8;
            constexpr int io_error = -9;
            constexpr int network_error = -10;
            constexpr int internal_error = -99;
        }
        // Legacy compatibility
        namespace common {
            constexpr int invalid_argument = common_errors::invalid_argument;
            constexpr int not_initialized = common_errors::not_initialized;
            constexpr int already_exists = common_errors::already_exists;
            constexpr int internal_error = -99;
        }
    }
 
    // Extended error codes (for API compatibility with KCENON_WITH_COMMON_SYSTEM path)
    namespace error_codes_ext {
        namespace network_system {
            constexpr int circuit_open = -604; 
        }
    }
 
    // Helper functions
    template<typename T>
    inline Result<T> ok(T&& value) {
        return Result<T>(std::forward<T>(value));
    }
 
    inline VoidResult ok() {
        return VoidResult(std::monostate{});
    }
 
    template<typename T>
    inline Result<T> error(int code, const std::string& message,
                          const std::string& source = "network_system",
                          const std::string& details = "") {
        return Result<T>(simple_error(code, message, source, details));
    }
 
    inline VoidResult error_void(int code, const std::string& message,
                                const std::string& source = "network_system",
                                const std::string& details = "") {
        return VoidResult(simple_error(code, message, source, details));
    }
 
    // Helper to extract details string from simple_error (string type)
    inline std::string get_error_details(const simple_error& err) {
        return err.details;
    }
 
    // Helper to extract source string from simple_error
    inline const std::string& get_error_source(const simple_error& err) {
        return err.source;
    }
 
#endif
 
} // namespace kcenon::network