Book.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <boost/utility/base_from_member.hpp>
 
#include <compare>
#include <cstddef>
#include <functional>
#include <optional>
#include <ostream>
#include <string>
 
namespace xrpl {

class Book final : public CountedObject<Book>
{
public:
    Asset in;
    Asset out;
    std::optional<uint256> domain;
 
    Book() = default;
 
    Book(Asset const& in, Asset const& out, std::optional<uint256> const& domain)
        : in(in), out(out), domain(domain)
    {
    }
};
 
bool
isConsistent(Book const& book);
 
std::string
to_string(Book const& book);
 
std::ostream&
operator<<(std::ostream& os, Book const& x);
 
template <class Hasher>
void
hash_append(Hasher& h, Book const& b)
{
    using beast::hash_append;
    hash_append(h, b.in, b.out);
    if (b.domain)
        hash_append(h, *(b.domain));
}
 
Book
reversed(Book const& book);

[[nodiscard]] constexpr bool
operator==(Book const& lhs, Book const& rhs)
{
    return (lhs.in == rhs.in) && (lhs.out == rhs.out) && (lhs.domain == rhs.domain);
}


[[nodiscard]] constexpr std::weak_ordering
operator<=>(Book const& lhs, Book const& rhs)
{
    if (auto const c{lhs.in <=> rhs.in}; c != 0)  // NOLINT(modernize-use-nullptr)
        return c;
    if (auto const c{lhs.out <=> rhs.out}; c != 0)  // NOLINT(modernize-use-nullptr)
        return c;
 
    // Manually compare optionals
    if (lhs.domain && rhs.domain)
        return *lhs.domain <=> *rhs.domain;  // Compare values if both exist
    if (!lhs.domain && rhs.domain)
        return std::weak_ordering::less;  // Empty is considered less
    if (lhs.domain && !rhs.domain)
        return std::weak_ordering::greater;  // Non-empty is greater
 
    return std::weak_ordering::equivalent;  // Both are empty
}

 
}  // namespace xrpl
 
//------------------------------------------------------------------------------
 
namespace std {
 
template <>
struct hash<xrpl::Issue> : private boost::base_from_member<std::hash<xrpl::Currency>, 0>,
                           private boost::base_from_member<std::hash<xrpl::AccountID>, 1>
{
private:
    using currency_hash_type = boost::base_from_member<std::hash<xrpl::Currency>, 0>;
    using issuer_hash_type = boost::base_from_member<std::hash<xrpl::AccountID>, 1>;
 
public:
    hash() = default;
 
    using value_type = std::size_t;
    using argument_type = xrpl::Issue;
 
    value_type
    operator()(argument_type const& value) const
    {
        value_type result(currency_hash_type::member(value.currency));
        if (!isXRP(value.currency))
            boost::hash_combine(result, issuer_hash_type::member(value.account));
        return result;
    }
};
 
template <>
struct hash<xrpl::MPTIssue> : private boost::base_from_member<std::hash<xrpl::MPTID>, 0>
{
private:
    using id_hash_type = boost::base_from_member<std::hash<xrpl::MPTID>, 0>;
 
public:
    explicit hash() = default;
 
    using value_type = std::size_t;
    using argument_type = xrpl::MPTIssue;
 
    value_type
    operator()(argument_type const& value) const
    {
        value_type const result(id_hash_type::member(value.getMptID()));
        return result;
    }
};
 
template <>
struct hash<xrpl::Asset>
{
private:
    using value_type = std::size_t;
    using argument_type = xrpl::Asset;
 
    using issue_hasher = std::hash<xrpl::Issue>;
    using mptissue_hasher = std::hash<xrpl::MPTIssue>;
 
    issue_hasher mIssueHasher_;
    mptissue_hasher mMptissueHasher_;
 
public:
    explicit hash() = default;
 
    value_type
    operator()(argument_type const& asset) const
    {
        return asset.visit(
            [&](xrpl::Issue const& issue) {
                value_type const result(mIssueHasher_(issue));
                return result;
            },
            [&](xrpl::MPTIssue const& issue) {
                value_type const result(mMptissueHasher_(issue));
                return result;
            });
    }
};
 
//------------------------------------------------------------------------------
 
template <>
struct hash<xrpl::Book>
{
private:
    using asset_hasher = std::hash<xrpl::Asset>;
    using uint256_hasher = xrpl::uint256::hasher;
 
    asset_hasher issueHasher_;
    uint256_hasher uint256Hasher_;
 
public:
    hash() = default;
 
    using value_type = std::size_t;
    using argument_type = xrpl::Book;
 
    value_type
    operator()(argument_type const& value) const
    {
        value_type result(issueHasher_(value.in));
        boost::hash_combine(result, issueHasher_(value.out));
 
        if (value.domain)
            boost::hash_combine(result, uint256Hasher_(*value.domain));
 
        return result;
    }
};
 
}  // namespace std
 
//------------------------------------------------------------------------------
 
namespace boost {
 
template <>
struct hash<xrpl::Issue> : std::hash<xrpl::Issue>
{
    hash() = default;
 
    using Base = std::hash<xrpl::Issue>;
    // VFALCO NOTE broken in vs2012
    // using Base::Base; // inherit ctors
};
 
template <>
struct hash<xrpl::MPTIssue> : std::hash<xrpl::MPTIssue>
{
    explicit hash() = default;
 
    using Base = std::hash<xrpl::MPTIssue>;
};
 
template <>
struct hash<xrpl::Asset> : std::hash<xrpl::Asset>
{
    explicit hash() = default;
 
    using Base = std::hash<xrpl::Asset>;
};
 
template <>
struct hash<xrpl::Book> : std::hash<xrpl::Book>
{
    hash() = default;
 
    using Base = std::hash<xrpl::Book>;
    // VFALCO NOTE broken in vs2012
    // using Base::Base; // inherit ctors
};
 
}  // namespace boost