STVector256.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/Serializer.h>
 
#include <cstddef>
#include <utility>
#include <vector>
 
namespace xrpl {
 
class STVector256 : public STBase, public CountedObject<STVector256>
{
    std::vector<UInt256> value_;
 
public:
    using value_type = std::vector<UInt256> const&;
 
    STVector256() = default;
 
    explicit STVector256(SField const& n);
    explicit STVector256(std::vector<UInt256> vector);
    STVector256(SField const& n, std::vector<UInt256> vector);
    STVector256(SerialIter& sit, SField const& name);
 
    [[nodiscard]] SerializedTypeID
    getSType() const override;
 
    void
    add(Serializer& s) const override;
 
    [[nodiscard]] json::Value getJson(JsonOptions) const override;
 
    [[nodiscard]] bool
    isEquivalent(STBase const& t) const override;
 
    [[nodiscard]] bool
    isDefault() const override;
 
    STVector256&
    operator=(std::vector<UInt256> const& v);
 
    STVector256&
    operator=(std::vector<UInt256>&& v);
 
    void
    setValue(STVector256 const& v);

    explicit
    operator std::vector<UInt256>() const;
 
    [[nodiscard]] std::size_t
    size() const;
 
    void
    resize(std::size_t n);
 
    [[nodiscard]] bool
    empty() const;
 
    std::vector<UInt256>::reference
    operator[](std::vector<UInt256>::size_type n);
 
    std::vector<UInt256>::const_reference
    operator[](std::vector<UInt256>::size_type n) const;
 
    [[nodiscard]] std::vector<UInt256> const&
    value() const;
 
    std::vector<UInt256>::iterator
    insert(std::vector<UInt256>::const_iterator pos, UInt256 const& value);
 
    void
    pushBack(UInt256 const& v);
 
    std::vector<UInt256>::iterator
    begin();
 
    [[nodiscard]] std::vector<UInt256>::const_iterator
    begin() const;
 
    std::vector<UInt256>::iterator
    end();
 
    [[nodiscard]] std::vector<UInt256>::const_iterator
    end() const;
 
    std::vector<UInt256>::iterator
    erase(std::vector<UInt256>::iterator position);
 
    void
    clear() noexcept;
 
private:
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend class detail::STVar;
};
 
inline STVector256::STVector256(SField const& n) : STBase(n)
{
}
 
inline STVector256::STVector256(std::vector<UInt256> vector) : value_(std::move(vector))
{
}
 
inline STVector256::STVector256(SField const& n, std::vector<UInt256> vector)
    : STBase(n), value_(std::move(vector))
{
}
 
inline STVector256&
STVector256::operator=(std::vector<UInt256> const& v)
{
    value_ = v;
    return *this;
}
 
inline STVector256&
STVector256::operator=(std::vector<UInt256>&& v)
{
    value_ = std::move(v);
    return *this;
}
 
inline void
STVector256::setValue(STVector256 const& v)
{
    value_ = v.value_;
}

inline STVector256::
operator std::vector<UInt256>() const
{
    return value_;
}
 
inline std::size_t
STVector256::size() const
{
    return value_.size();
}
 
inline void
STVector256::resize(std::size_t n)
{
    value_.resize(n);
}
 
inline bool
STVector256::empty() const
{
    return value_.empty();
}
 
inline std::vector<UInt256>::reference
STVector256::operator[](std::vector<UInt256>::size_type n)
{
    return value_[n];
}
 
inline std::vector<UInt256>::const_reference
STVector256::operator[](std::vector<UInt256>::size_type n) const
{
    return value_[n];
}
 
inline std::vector<UInt256> const&
STVector256::value() const
{
    return value_;
}
 
inline std::vector<UInt256>::iterator
STVector256::insert(std::vector<UInt256>::const_iterator pos, UInt256 const& value)
{
    return value_.insert(pos, value);
}
 
inline void
STVector256::pushBack(UInt256 const& v)
{
    value_.push_back(v);
}
 
inline std::vector<UInt256>::iterator
STVector256::begin()
{
    return value_.begin();
}
 
inline std::vector<UInt256>::const_iterator
STVector256::begin() const
{
    return value_.begin();
}
 
inline std::vector<UInt256>::iterator
STVector256::end()
{
    return value_.end();
}
 
inline std::vector<UInt256>::const_iterator
STVector256::end() const
{
    return value_.end();
}
 
inline std::vector<UInt256>::iterator
STVector256::erase(std::vector<UInt256>::iterator position)
{
    return value_.erase(position);
}
 
inline void
STVector256::clear() noexcept
{
    value_.clear();
}
 
}  // namespace xrpl