Types.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "web/SubscriptionContextInterface.hpp"
 
#include <boost/asio/spawn.hpp>
#include <boost/json/array.hpp>
#include <boost/json/conversion.hpp>
#include <boost/json/object.hpp>
#include <boost/json/value.hpp>
#include <boost/json/value_from.hpp>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/strHex.h>
 
#include <cstdint>
#include <expected>
#include <string>
#include <utility>
#include <variant>
 
namespace etl {
class LoadBalancer;
}  // namespace etl
namespace web {
struct ConnectionBase;
}  // namespace web
 
namespace rpc {
 
class Counters;

using MaybeError = std::expected<void, Status>;

inline bool
operator==(MaybeError const& lhs, MaybeError const& rhs)
{
    bool const lhsHasError = !static_cast<bool>(lhs);
    bool const rhsHasError = !static_cast<bool>(rhs);
    return lhsHasError == rhsHasError && (!lhsHasError || lhs.error() == rhs.error());
}

using Error = std::unexpected<Status>;

template <typename OutputType>
using HandlerReturnType = std::expected<OutputType, Status>;

struct ReturnType {
    ReturnType(std::expected<boost::json::value, Status> result, boost::json::array warnings = {})
        : result{std::move(result)}, warnings(std::move(warnings))
    {
    }

    operator bool() const
    {
        return result.has_value();
    }
 
    std::expected<boost::json::value, Status> result;
    boost::json::array warnings;
};

struct VoidOutput {};

struct Context {
    boost::asio::yield_context yield;
    web::SubscriptionContextPtr session = {};  // NOLINT(readability-redundant-member-init)
    bool isAdmin = false;
    std::string clientIp = {};  // NOLINT(readability-redundant-member-init)
    uint32_t apiVersion = 0u;   // invalid by default
};

struct Result {
    explicit Result(ReturnType returnType)
    {
        if (returnType) {
            response = std::move(returnType.result).value().as_object();
        } else {
            response = std::unexpected{std::move(returnType.result).error()};
        }
        warnings = std::move(returnType.warnings);
    }

    explicit Result(Status status) : response{std::unexpected{std::move(status)}}
    {
    }

    explicit Result(boost::json::object response) : response{std::move(response)}
    {
    }
 
    std::expected<boost::json::object, Status> response;
    boost::json::array warnings;
};

struct AccountCursor {
    ripple::uint256 index;
    std::uint32_t hint{};

    std::string
    toString() const
    {
        return ripple::strHex(index) + "," + std::to_string(hint);
    }

    bool
    isNonZero() const
    {
        return index.isNonZero() || hint != 0;
    }
};

inline void
tag_invoke(boost::json::value_from_tag, boost::json::value& jv, VoidOutput const&)
{
    jv = boost::json::object{};
}
 
}  // namespace rpc