Status.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/TER.h>
 
#include <exception>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace xrpl::rpc {

struct Status : public std::exception
{
public:
    enum class Type { None, TER, ErrorCodeI };
    using Code = int;
    using Strings = std::vector<std::string>;
 
    static constexpr Code kOK = 0;
 
    Status() = default;
 
    // The constraint allows only integers (not enums).  Prevents enum narrowing.
    template <typename T>
    Status(T code, Strings d = {})
        requires(std::is_integral_v<T>)
        : code_(code), messages_(std::move(d))
    {
    }
 
    Status(TER ter, Strings d = {})
        : type_(Type::TER), code_(TERtoInt(ter)), messages_(std::move(d))
    {
    }
 
    Status(ErrorCodeI e, Strings d = {})
        : type_(Type::ErrorCodeI), code_(e), messages_(std::move(d))
    {
    }
 
    Status(ErrorCodeI e, std::string const& s) : type_(Type::ErrorCodeI), code_(e), messages_({s})
    {
    }

    [[nodiscard]] std::string
    codeString() const;

    operator bool() const
    {
        return code_ != kOK;
    }

    bool
    operator!() const
    {
        return !bool(*this);
    }

    [[nodiscard]] TER
    toTER() const
    {
        XRPL_ASSERT(type_ == Type::TER, "xrpl::rpc::Status::toTER : type is TER");
        return TER::fromInt(code_);
    }

    [[nodiscard]] ErrorCodeI
    toErrorCode() const
    {
        XRPL_ASSERT(
            type_ == Type::ErrorCodeI, "xrpl::rpc::Status::toErrorCode : type is error code");
        return ErrorCodeI(code_);
    }

    void
    inject(json::Value& object) const
    {
        if (auto ec = toErrorCode())
        {
            if (messages_.empty())
            {
                injectError(ec, object);
            }
            else
            {
                injectError(ec, message(), object);
            }
        }
    }
 
    [[nodiscard]] Strings const&
    messages() const
    {
        return messages_;
    }

    [[nodiscard]] std::string
    message() const;
 
    [[nodiscard]] Type
    type() const
    {
        return type_;
    }
 
    [[nodiscard]] std::string
    toString() const;

    void
    fillJson(json::Value&);
 
private:
    Type type_ = Type::None;
    Code code_ = kOK;
    Strings messages_;
};
 
}  // namespace xrpl::rpc