Result.hpp

//
//  Result.hpp
//  SwitchboardSDK
//
//  Copyright © 2026 Synervoz. All rights reserved.
//
 
#pragma once
 
#include "export.h"
 
#include <switchboard/SBAny.hpp>
#include <optional>
#include <string>
#include <variant>
#include <stdexcept>
 
namespace switchboard {

struct SWITCHBOARDSDK_EXPORT Error {
    std::string message;

    Error(std::string msg) : message(std::move(msg)) {}
};

template <typename T>
class SWITCHBOARDSDK_EXPORT Result {
private:
    using ValueType = std::conditional_t<std::is_void_v<T>, std::monostate, T>;
    std::variant<ValueType, Error> result;
 
public:
    explicit Result(ValueType value) : result(std::move(value)) {}
    explicit Result(Error error) : result(std::move(error)) {}

    [[nodiscard]] bool isSuccess() const {
        return std::holds_alternative<ValueType>(result);
    }

    [[nodiscard]] bool isError() const {
        return std::holds_alternative<Error>(result);
    }

    [[nodiscard]] ValueType value() const {
        if (!isSuccess()) {
            throw std::runtime_error("Result does not contain a value, operation failed.");
        }
        return std::get<ValueType>(result);
    }

    [[nodiscard]] Error error() const {
        if (!isError()) {
            throw std::runtime_error("Result does not contain an error, operation was successful.");
        }
        return std::get<Error>(result);
    }

    [[nodiscard]] Result<SBAny> toAny() const {
        if (isSuccess()) {
            return Result<SBAny>(SBAny(value()));
        } else {
            return Result<SBAny>(Error(error().message));
        }
    }
};

template <typename T>
Result<T> makeSuccess(T value) {
    return Result<T>(std::move(value));
}

inline Result<void> makeSuccess() {
    return Result<void>(std::monostate {});
}

template <typename T>
Result<T> makeError(std::string errorMessage) {
    return Result<T>(Error(std::move(errorMessage)));
}
 
}