core.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
 
// Import C++17-compatible source_location
#include <kcenon/common/utils/source_location.h>
 
// Import new error_code type for category-based error handling
#include <kcenon/common/error/error_category.h>
 
namespace kcenon::common {
 
// Forward declaration to avoid circular dependency
// error_code is defined in error_category.h
 
// ============================================================================
// Forward Declarations (from fwd.h)
// ============================================================================
 
// Forward declarations
struct error_info;
template<typename T> class Result;
template<typename T> class Optional;
 
enum class result_state {
    uninitialized,  // Result has not been initialized with a value or error
    ok,             // Result contains a valid value
    error           // Result contains an error
};
 
using VoidResult = Result<std::monostate>;
 
// ============================================================================
// Error Info (from error_info.h)
// ============================================================================
 
struct error_info {
    int code;
    std::string message;
    std::string module;
    std::optional<std::string> details;
 
    error_info() : code(0) {}
 
    error_info(const std::string& msg)
        : code(-1), message(msg), module("") {}
 
    error_info(int c, const std::string& msg, const std::string& mod = "")
        : code(c), message(msg), module(mod) {}
 
    error_info(int c, const std::string& msg, const std::string& mod,
               const std::string& det)
        : code(c), message(msg), module(mod), details(det) {}
 
    template<typename Enum,
             typename std::enable_if_t<std::is_enum_v<Enum>, int> = 0>
    error_info(Enum c, std::string msg, std::string mod = "",
               std::optional<std::string> det = std::nullopt)
        : code(static_cast<int>(c)),
          message(std::move(msg)),
          module(std::move(mod)),
          details(std::move(det)) {}
 
    bool operator==(const error_info& other) const {
        return code == other.code && message == other.message &&
               module == other.module && details == other.details;
    }
 
    bool operator!=(const error_info& other) const {
        return !(*this == other);
    }
 
    error_info(const typed_error_code& ec)
        : code(ec.value()),
          message(ec.message()),
          module(std::string(ec.category_name())) {}
};
 
 
// ============================================================================
// Result<T> Class (from result_core.h)
// ============================================================================
 
template<typename T>
class Result {
public:
    using value_type = T;
 
    using error_type = error_info;
 
private:
    // Use std::optional<T> for value, which naturally supports uninitialized state
    // Store error separately to avoid variant issues
    std::optional<T> value_;
    std::optional<error_info> error_;
 
public:
    // Constructors - public but encourage use of factory methods
    Result(const T& value) : value_(value), error_(std::nullopt) {}
    Result(T&& value) : value_(std::move(value)), error_(std::nullopt) {}
    Result(const error_info& error) : value_(std::nullopt), error_(error) {}
    Result(error_info&& error) : value_(std::nullopt), error_(std::move(error)) {}
 
    Result(const typed_error_code& ec) : value_(std::nullopt), error_(error_info(ec)) {}
    Result() = delete;
 
    // Copy and move
    Result(const Result&) = default;
    Result(Result&&) = default;
    Result& operator=(const Result&) = default;
    Result& operator=(Result&&) = default;
 
    // Static factory methods (Rust-style API)
    template<typename U = T>
    static Result<T> ok(U&& value) {
        return Result<T>(std::forward<U>(value));
    }
 
    static Result<T> err(const error_info& error) {
        return Result<T>(error);
    }
 
    static Result<T> err(error_info&& error) {
        return Result<T>(std::move(error));
    }
 
    static Result<T> err(int code, const std::string& message, const std::string& module = "") {
        return Result<T>(error_info{code, message, module});
    }
 
    static Result<T> err(const typed_error_code& ec) {
        return Result<T>(ec);
    }
 
    static Result<T> uninitialized() {
        return Result<T>(error_info{-6, "Result not initialized", "common::Result"});
    }
 
    bool is_ok() const {
        return value_.has_value();
    }
 
    bool is_err() const {
        return error_.has_value();
    }
 
#if KCENON_HAS_SOURCE_LOCATION
    const T& unwrap(
        source_location loc = source_location::current()
    ) const {
        if (is_err()) {
            const auto& err = error_.value();
            std::ostringstream oss;
            oss << "Called unwrap on error: " << err.message << "\n"
                << "  Error code: " << err.code << "\n"
                << "  Module: " << (err.module.empty() ? "unknown" : err.module) << "\n"
                << "  Location: " << loc.file_name() << ":" << loc.line() << ":" << loc.column() << "\n"
                << "  Function: " << loc.function_name();
            if (err.details.has_value()) {
                oss << "\n  Details: " << err.details.value();
            }
            throw std::runtime_error(oss.str());
        }
        return value_.value();
    }
#else
    const T& unwrap() const {
        if (is_err()) {
            const auto& err = error_.value();
            throw std::runtime_error("Called unwrap on error: " + err.message);
        }
        return value_.value();
    }
#endif
 
#if KCENON_HAS_SOURCE_LOCATION
    T& unwrap(
        source_location loc = source_location::current()
    ) {
        if (is_err()) {
            const auto& err = error_.value();
            std::ostringstream oss;
            oss << "Called unwrap on error: " << err.message << "\n"
                << "  Error code: " << err.code << "\n"
                << "  Module: " << (err.module.empty() ? "unknown" : err.module) << "\n"
                << "  Location: " << loc.file_name() << ":" << loc.line() << ":" << loc.column() << "\n"
                << "  Function: " << loc.function_name();
            if (err.details.has_value()) {
                oss << "\n  Details: " << err.details.value();
            }
            throw std::runtime_error(oss.str());
        }
        return value_.value();
    }
#else
    T& unwrap() {
        if (is_err()) {
            const auto& err = error_.value();
            throw std::runtime_error("Called unwrap on error: " + err.message);
        }
        return value_.value();
    }
#endif
 
    T unwrap_or(T default_value) const {
        if (is_ok()) {
            return value_.value();
        }
        return default_value;
    }
 
    T value_or(T default_value) const {
        return unwrap_or(std::move(default_value));
    }
 
    const T& value() const {
        return value_.value();
    }
 
    T& value() {
        return value_.value();
    }
 
    const error_info& error() const {
        return error_.value();
    }
 
    template<typename F>
    auto map(F&& func) const -> Result<decltype(func(std::declval<T>()))> {
        using ReturnType = decltype(func(std::declval<T>()));
 
        if (is_ok()) {
            return Result<ReturnType>(func(value_.value()));
        } else if (is_err()) {
            return Result<ReturnType>(error_.value());
        } else {
            // Uninitialized state - use uninitialized factory
            return Result<ReturnType>::uninitialized();
        }
    }
 
    template<typename F>
    auto and_then(F&& func) const -> decltype(func(std::declval<T>())) {
        using ReturnType = decltype(func(std::declval<T>()));
 
        if (is_ok()) {
            return func(value_.value());
        } else if (is_err()) {
            return ReturnType(error_.value());
        } else {
            // Uninitialized state - use uninitialized factory
            return ReturnType::uninitialized();
        }
    }
 
    template<typename F>
    Result<T> or_else(F&& func) const {
        if (is_ok()) {
            return *this;
        } else if (is_err()) {
            return func(error_.value());
        } else {
            // Uninitialized state
            return *this;
        }
    }
};
 
// ============================================================================
// Optional<T> Class (from optional.h)
// ============================================================================
 
template<typename T>
class Optional {
public:
    using value_type = T;
 
private:
    std::optional<T> value_;
 
public:
    Optional() : value_(std::nullopt) {}
    Optional(const T& value) : value_(value) {}
    Optional(T&& value) : value_(std::move(value)) {}
    Optional(std::nullopt_t) : value_(std::nullopt) {}
 
    bool has_value() const { return value_.has_value(); }
    bool is_some() const { return value_.has_value(); }
    bool is_none() const { return !value_.has_value(); }
 
    const T& value() const { return value_.value(); }
    T& value() { return value_.value(); }
 
#if KCENON_HAS_SOURCE_LOCATION
    const T& unwrap(
        source_location loc = source_location::current()
    ) const {
        if (!has_value()) {
            std::ostringstream oss;
            oss << "Called unwrap on None\n"
                << "  Location: " << loc.file_name() << ":" << loc.line() << ":" << loc.column() << "\n"
                << "  Function: " << loc.function_name();
            throw std::runtime_error(oss.str());
        }
        return value_.value();
    }
#else
    const T& unwrap() const {
        if (!has_value()) {
            throw std::runtime_error("Called unwrap on None");
        }
        return value_.value();
    }
#endif
 
    T unwrap_or(T default_value) const {
        return value_.value_or(default_value);
    }
 
    template<typename F>
    auto map(F&& func) const -> Optional<decltype(func(std::declval<T>()))> {
        using ReturnType = decltype(func(std::declval<T>()));
 
        if (has_value()) {
            return Optional<ReturnType>(func(value_.value()));
        } else {
            return Optional<ReturnType>(std::nullopt);
        }
    }
};
 
// Optional factory functions
 
template<typename T>
inline Optional<T> Some(T value) {
    return Optional<T>(std::move(value));
}
 
template<typename T>
inline Optional<T> None() {
    return Optional<T>(std::nullopt);
}
 
} // namespace kcenon::common