NET_Outcome.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_Outcome.h
 *
 * COMMENTS:
 *                      
 *
 */

#ifndef __NET_OUTCOME_H__
#define __NET_OUTCOME_H__

#include "NET_API.h"

#include <UT/UT_BoostAsio.h>
#include <UT/UT_ErrorCode.h>

#include <exception>
#include <variant>

template <typename T, typename E>
struct net_OutcomeValueVisit
{
using result_type = T&;
result_type operator()(T& value) { return value; }
result_type operator()(const E& err) { throw std::system_error(err); }
result_type operator()(const std::exception_ptr& ptr) { std::rethrow_exception(ptr); }
};

template <typename T, typename E>
struct net_OutcomeErrorVisit
{
using result_type = const E&;
result_type operator()(const T&) { throw std::logic_error("holds value not error."); }
result_type operator()(const E& e) { return e; }
result_type operator()(const std::exception_ptr& ptr) { std::rethrow_exception(ptr); }
};

template <typename T, typename E>
struct net_OutcomeExceptionVisit
{
using result_type = std::exception_ptr;
result_type operator()(const T&) { throw std::logic_error("holds exception not value."); }
result_type operator()(const E& e) { throw std::system_error(e); }
result_type operator()(const std::exception_ptr& ptr) { return ptr; }
};

template <typename T, typename E = UT_ErrorCode>
class NET_Outcome
{
public:
    using value_type = T;
    using error_type = E;
    using exception_type = std::exception_ptr;

    NET_Outcome(T value) : myValue(std::move(value)) {}
    NET_Outcome(const E& err) : myValue(err) {}
    NET_Outcome(const std::exception_ptr& ptr) : myValue(ptr) {}

    bool hasValue() const { return std::holds_alternative<T>(myValue); }
    bool hasError() const { return std::holds_alternative<E>(myValue); }
    bool hasException() const { return std::holds_alternative<exception_type>(myValue); }

    T& value() &
    {
        return std::visit(net_OutcomeValueVisit<T,E>(), myValue);
    }
    const T& value() const &
    {
        return std::visit(net_OutcomeValueVisit<const T,E>(), myValue);
    }
    T&& value() &&
    {
        return std::move(this->value());
    }
    const error_type& error() const
    {
        return std::visit(net_OutcomeErrorVisit<T,E>(), myValue);
    }
    exception_type exceptionPtr() const
    {
        return std::visit(net_OutcomeExceptionVisit<T,E>(), myValue);
    }

private:
    std::variant<T, E, std::exception_ptr> myValue;
};

#endif // __NET_OUTCOME_H__