SOTemplate.h

#pragma once
 
#include <xrpl/basics/contract.h>
#include <xrpl/protocol/SField.h>
 
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace xrpl {

// 2026 usages, 129 files
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum SOEStyle {
    SoeInvalid = -1,
    SoeRequired = 0,  // required
    SoeOptional = 1,  // optional, may be present with default value
    SoeDefault = 2,   // optional, if present, must not have default value
                      // inner object with the default fields has to be
                      // constructed with STObject::makeInnerObject()
};
 
// Part of a Python-parsed DSL (transactions.macro); bare enumerator names required by the parser
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum SOETxMPTIssue { SoeMptNone, SoeMptSupported, SoeMptNotSupported };
 
//------------------------------------------------------------------------------

class SOElement
{
    // Use std::reference_wrapper so SOElement can be stored in a std::vector.
    std::reference_wrapper<SField const> sField_;
    SOEStyle style_;
    SOETxMPTIssue supportMpt_ = SoeMptNone;
 
private:
    void
    init(SField const& fieldName) const
    {
        if (!sField_.get().isUseful())
        {
            auto nm = std::to_string(fieldName.getCode());
            if (fieldName.hasName())
                nm += ": '" + fieldName.getName() + "'";
            Throw<std::runtime_error>("SField (" + nm + ") in SOElement must be useful.");
        }
    }
 
public:
    SOElement(SField const& fieldName, SOEStyle style) : sField_(fieldName), style_(style)
    {
        init(fieldName);
    }
 
    template <typename T>
        requires(std::is_same_v<T, STAmount> || std::is_same_v<T, STIssue>)
    SOElement(
        TypedField<T> const& fieldName,
        SOEStyle style,
        SOETxMPTIssue supportMpt = SoeMptNotSupported)
        : sField_(fieldName), style_(style), supportMpt_(supportMpt)
    {
        init(fieldName);
    }
 
    [[nodiscard]] SField const&
    sField() const
    {
        return sField_.get();
    }
 
    [[nodiscard]] SOEStyle
    style() const
    {
        return style_;
    }
 
    [[nodiscard]] SOETxMPTIssue
    supportMPT() const
    {
        return supportMpt_;
    }
};
 
//------------------------------------------------------------------------------

class SOTemplate
{
public:
    // Copying vectors is expensive.  Make this a move-only type until
    // there is motivation to change that.
    SOTemplate(SOTemplate&& other) = default;
    SOTemplate&
    operator=(SOTemplate&& other) = default;

    SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields = {});

    SOTemplate(
        std::initializer_list<SOElement> uniqueFields,
        std::initializer_list<SOElement> commonFields = {});
 
    /* Provide for the enumeration of fields */
    [[nodiscard]] std::vector<SOElement>::const_iterator
    begin() const
    {
        return elements_.cbegin();
    }
 
    [[nodiscard]] std::vector<SOElement>::const_iterator
    cbegin() const
    {
        return begin();
    }
 
    [[nodiscard]] std::vector<SOElement>::const_iterator
    end() const
    {
        return elements_.cend();
    }
 
    [[nodiscard]] std::vector<SOElement>::const_iterator
    cend() const
    {
        return end();
    }

    [[nodiscard]] std::size_t
    size() const
    {
        return elements_.size();
    }

    [[nodiscard]] int
    getIndex(SField const&) const;
 
    [[nodiscard]] SOEStyle
    style(SField const& sf) const
    {
        return elements_[indices_[sf.getNum()]].style();
    }
 
private:
    std::vector<SOElement> elements_;
    std::vector<int> indices_;  // field num -> index
};
 
}  // namespace xrpl