STBase.h

#pragma once
 
#include <xrpl/basics/contract.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/Serializer.h>
 
#include <concepts>
#include <cstddef>
#include <ostream>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <utility>
 
namespace xrpl {

struct JsonOptions
{
    using underlying_t = unsigned int;
    underlying_t value;
 
    enum class Values : underlying_t {
        None = 0b0000'0000,
        IncludeDate = 0b0000'0001,
        DisableApiPriorV2 = 0b0000'0010,
 
        // IMPORTANT `All` must be union of all of the above; see also operator~
        All = IncludeDate | DisableApiPriorV2  // 0b0000'0011
    };
 
    constexpr JsonOptions(underlying_t v) noexcept : value(v)
    {
    }
 
    constexpr JsonOptions(Values v) noexcept : value(static_cast<JsonOptions::underlying_t>(v))
    {
    }
 
    [[nodiscard]] constexpr explicit
    operator underlying_t() const noexcept
    {
        return value;
    }
    [[nodiscard]] constexpr explicit
    operator bool() const noexcept
    {
        return value != 0u;
    }
    [[nodiscard]] constexpr auto friend
    operator==(JsonOptions lh, JsonOptions rh) noexcept -> bool = default;
    [[nodiscard]] constexpr auto friend
    operator!=(JsonOptions lh, JsonOptions rh) noexcept -> bool = default;

    [[nodiscard]] constexpr JsonOptions friend
    operator|(JsonOptions lh, JsonOptions rh) noexcept
    {
        return {lh.value | rh.value};
    }

    [[nodiscard]] constexpr JsonOptions friend
    operator&(JsonOptions lh, JsonOptions rh) noexcept
    {
        return {lh.value & rh.value};
    }

    [[nodiscard]] constexpr JsonOptions friend
    operator~(JsonOptions v) noexcept
    {
        return {~v.value & static_cast<underlying_t>(Values::All)};
    }
};
 
template <typename T>
    requires requires(T const& t) {
        { t.getJson(JsonOptions::Values::None) } -> std::convertible_to<json::Value>;
    }
json::Value
toJson(T const& t)
{
    return t.getJson(JsonOptions::Values::None);
}
 
namespace detail {
class STVar;
}  // namespace detail
 
// VFALCO TODO fix this restriction on copy assignment.
//
// CAUTION: Do not create a vector (or similar container) of any object derived
// from STBase. Use Boost ptr_* containers. The copy assignment operator
// of STBase has semantics that will cause contained types to change
// their names when an object is deleted because copy assignment is used to
// "slide down" the remaining types and this will not copy the field
// name. Changing the copy assignment operator to copy the field name breaks the
// use of copy assignment just to copy values, which is used in the transaction
// engine code.
 
//------------------------------------------------------------------------------

class STBase
{
    SField const* fName_;
 
public:
    virtual ~STBase() = default;
    STBase();
    STBase(STBase const&) = default;
    STBase&
    operator=(STBase const& t);
 
    explicit STBase(SField const& n);
 
    bool
    operator==(STBase const& t) const;
 
    template <class D>
    D&
    downcast();
 
    template <class D>
    D const&
    downcast() const;
 
    [[nodiscard]] virtual SerializedTypeID
    getSType() const;
 
    [[nodiscard]] virtual std::string
    getFullText() const;
 
    [[nodiscard]] virtual std::string
    getText() const;
 
    [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::Values::None) const;
 
    virtual void
    add(Serializer& s) const;
 
    [[nodiscard]] virtual bool
    isEquivalent(STBase const& t) const;
 
    [[nodiscard]] virtual bool
    isDefault() const;

    void
    setFName(SField const& n);
 
    [[nodiscard]] SField const&
    getFName() const;
 
    void
    addFieldID(Serializer& s) const;
 
protected:
    template <class T>
    static STBase*
    emplace(std::size_t n, void* buf, T&& val);
 
private:
    virtual STBase*
    copy(std::size_t n, void* buf) const;
    virtual STBase*
    move(std::size_t n, void* buf);
 
    friend class detail::STVar;
};
 
//------------------------------------------------------------------------------
 
std::ostream&
operator<<(std::ostream& out, STBase const& t);
 
template <class D>
D&
STBase::downcast()
{
    D* ptr = dynamic_cast<D*>(this);
    if (ptr == nullptr)
        Throw<std::bad_cast>();
    return *ptr;
}
 
template <class D>
[[nodiscard]] D const&
STBase::downcast() const
{
    D const* ptr = dynamic_cast<D const*>(this);
    if (ptr == nullptr)
        Throw<std::bad_cast>();
    return *ptr;
}
 
template <class T>
STBase*
STBase::emplace(std::size_t n, void* buf, T&& val)
{
    using U = std::decay_t<T>;
    if (sizeof(U) > n)
        return new U(std::forward<T>(val));
    return new (buf) U(std::forward<T>(val));
}
 
}  // namespace xrpl