ignite_result.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include "ignite_error.h"
 
#include <functional>
#include <future>
#include <optional>
#include <string>
#include <variant>
 
namespace ignite {

template<typename T>
class ignite_result {
public:
    // Default
    ignite_result() = default;

    ignite_result(T &&value) // NOLINT(google-explicit-constructor)
        : m_value(std::move(value)) {}

    ignite_result(ignite_error &&error) // NOLINT(google-explicit-constructor)
        : m_value(std::move(error)) {}

    [[nodiscard]] bool has_value() const noexcept { return !has_error(); }

    [[nodiscard]] bool has_error() const noexcept { return std::holds_alternative<ignite_error>(m_value); }

    [[nodiscard]] T &&value() && {
        if (!has_value())
            throw ignite_error("No value is present in result");
 
        return std::get<T>(std::move(m_value));
    }

    [[nodiscard]] const T &value() const & {
        if (!has_value())
            throw ignite_error("No value is present in result");
 
        return std::get<T>(m_value);
    }

    [[nodiscard]] T &value() & {
        if (!has_value())
            throw ignite_error("No value is present in result");
 
        return std::get<T>(m_value);
    }

    [[nodiscard]] ignite_error &&error() && {
        if (!has_error())
            throw ignite_error("No error is present in result");
 
        return std::move(std::get<ignite_error>(m_value));
    }

    [[nodiscard]] const ignite_error &error() const & {
        if (!has_error())
            throw ignite_error("No error is present in result");
 
        return std::get<ignite_error>(m_value);
    }

    [[nodiscard]] ignite_error &error() & {
        if (!has_error())
            throw ignite_error("No error is present in result");
 
        return std::get<ignite_error>(m_value);
    }

    explicit operator bool() const noexcept { return !has_error(); }
 
private:
    std::variant<ignite_error, T> m_value;
};

template<>
class ignite_result<void> {
public:
    ignite_result()
        : m_error(std::nullopt) {}

    ignite_result(ignite_error &&error) // NOLINT(google-explicit-constructor)
        : m_error(std::move(error)) {}

    [[nodiscard]] bool has_error() const noexcept { return m_error.has_value(); }

    [[nodiscard]] ignite_error &&error() {
        if (!has_error())
            throw ignite_error("No error is present in result");
 
        return std::move(m_error.value());
    }

    [[nodiscard]] const ignite_error &error() const {
        if (!has_error())
            throw ignite_error("No error is present in result");
 
        return m_error.value();
    }

    explicit operator bool() const noexcept { return !has_error(); }
 
private:
    std::optional<ignite_error> m_error;
};
 
template<typename T>
using ignite_callback = std::function<void(ignite_result<T> &&)>;

template<typename T>
ignite_result<T> result_of_operation(const std::function<T()> &operation) noexcept {
    try {
        if constexpr (std::is_same_v<decltype(operation()), void>) {
            operation();
            return {};
        } else {
            return {operation()};
        }
    } catch (const ignite_error &err) {
        return {ignite_error(err)};
    } catch (const std::exception &err) {
        std::string msg("Standard library exception is thrown: ");
        msg += err.what();
        return {ignite_error(error::code::INTERNAL, msg, std::current_exception())};
    } catch (...) {
        return {ignite_error(error::code::INTERNAL, "Unknown error is encountered",
            std::current_exception())};
    }
}

template<typename T>
void result_set_promise(std::promise<T> &pr, ignite_result<T> &&res) {
    if (!res) {
        pr.set_exception(std::make_exception_ptr(std::move(res).error()));
    } else {
        if constexpr (std::is_same_v<T, void>) {
            pr.set_value();
        } else {
            pr.set_value(std::move(res).value());
        }
    }
}

template<typename T>
std::function<void(ignite_result<T>)> result_promise_setter(std::shared_ptr<std::promise<T>> pr) {
    return [pr = std::move(pr)](ignite_result<T> &&res) mutable { result_set_promise<T>(*pr, std::move(res)); };
}

template<typename T>
T sync(std::function<void(ignite_callback<T>)> func) {
    auto promise = std::make_shared<std::promise<T>>();
    func(result_promise_setter(promise));
    return promise->get_future().get();
}
 
} // namespace ignite