STBitString.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/Serializer.h>
 
#include <cstddef>
#include <string>
 
namespace xrpl {
 
// The template parameter could be an unsigned type, however there's a bug in
// gdb (last checked in gdb 12.1) that prevents gdb from finding the RTTI
// information of a template parameterized by an unsigned type. This RTTI
// information is needed to write gdb pretty printers.
template <int Bits>
class STBitString final : public STBase, public CountedObject<STBitString<Bits>>
{
    static_assert(Bits > 0, "Number of bits must be positive");
 
public:
    using value_type = BaseUInt<Bits>;
 
private:
    value_type value_{};
 
public:
    STBitString() = default;
 
    STBitString(SField const& n);
    STBitString(value_type const& v);
    STBitString(SField const& n, value_type const& v);
    STBitString(SerialIter& sit, SField const& name);
 
    [[nodiscard]] SerializedTypeID
    getSType() const override;
 
    [[nodiscard]] std::string
    getText() const override;
 
    [[nodiscard]] bool
    isEquivalent(STBase const& t) const override;
 
    void
    add(Serializer& s) const override;
 
    [[nodiscard]] bool
    isDefault() const override;
 
    template <typename Tag>
    void
    setValue(BaseUInt<Bits, Tag> const& v);
 
    [[nodiscard]] value_type const&
    value() const;
 
    operator value_type() const;
 
private:
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend class detail::STVar;
};
 
using STUInt128 = STBitString<128>;
using STUInt160 = STBitString<160>;
using STUInt192 = STBitString<192>;
using STUInt256 = STBitString<256>;
 
template <int Bits>
inline STBitString<Bits>::STBitString(SField const& n) : STBase(n)
{
}
 
template <int Bits>
inline STBitString<Bits>::STBitString(value_type const& v) : value_(v)
{
}
 
template <int Bits>
inline STBitString<Bits>::STBitString(SField const& n, value_type const& v) : STBase(n), value_(v)
{
}
 
template <int Bits>
inline STBitString<Bits>::STBitString(SerialIter& sit, SField const& name)
    : STBitString(name, sit.getBitString<Bits>())
{
}
 
template <int Bits>
STBase*
STBitString<Bits>::copy(std::size_t n, void* buf) const
{
    return emplace(n, buf, *this);
}
 
template <int Bits>
STBase*
STBitString<Bits>::move(std::size_t n, void* buf)
{
    return emplace(n, buf, std::move(*this));
}
 
template <>
inline SerializedTypeID
STUInt128::getSType() const
{
    return STI_UINT128;
}
 
template <>
inline SerializedTypeID
STUInt160::getSType() const
{
    return STI_UINT160;
}
 
template <>
inline SerializedTypeID
STUInt192::getSType() const
{
    return STI_UINT192;
}
 
template <>
inline SerializedTypeID
STUInt256::getSType() const
{
    return STI_UINT256;
}
 
template <int Bits>
std::string
STBitString<Bits>::getText() const
{
    return to_string(value_);
}
 
template <int Bits>
bool
STBitString<Bits>::isEquivalent(STBase const& t) const
{
    auto const* v = dynamic_cast<STBitString const*>(&t);
    return v && (value_ == v->value_);
}
 
template <int Bits>
void
STBitString<Bits>::add(Serializer& s) const
{
    XRPL_ASSERT(getFName().isBinary(), "xrpl::STBitString::add : field is binary");
    XRPL_ASSERT(getFName().fieldType == getSType(), "xrpl::STBitString::add : field type match");
    s.addBitString<Bits>(value_);
}
 
template <int Bits>
template <typename Tag>
void
STBitString<Bits>::setValue(BaseUInt<Bits, Tag> const& v)
{
    value_ = v;
}
 
template <int Bits>
STBitString<Bits>::value_type const&
STBitString<Bits>::value() const
{
    return value_;
}
 
template <int Bits>
STBitString<Bits>::
operator value_type() const
{
    return value_;
}
 
template <int Bits>
bool
STBitString<Bits>::isDefault() const
{
    return value_ == beast::kZero;
}
 
}  // namespace xrpl