SOTemplate.h

#ifndef XRPL_PROTOCOL_SOTEMPLATE_H_INCLUDED
#define XRPL_PROTOCOL_SOTEMPLATE_H_INCLUDED
 
#include <xrpl/basics/contract.h>
#include <xrpl/protocol/SField.h>
 
#include <functional>
#include <initializer_list>
#include <stdexcept>
 
namespace ripple {
 
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()
};
 
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);
    }
 
    SField const&
    sField() const
    {
        return sField_.get();
    }
 
    SOEStyle
    style() const
    {
        return style_;
    }
 
    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::initializer_list<SOElement> uniqueFields,
        std::initializer_list<SOElement> commonFields = {});
 
    /* Provide for the enumeration of fields */
    std::vector<SOElement>::const_iterator
    begin() const
    {
        return elements_.cbegin();
    }
 
    std::vector<SOElement>::const_iterator
    cbegin() const
    {
        return begin();
    }
 
    std::vector<SOElement>::const_iterator
    end() const
    {
        return elements_.cend();
    }
 
    std::vector<SOElement>::const_iterator
    cend() const
    {
        return end();
    }
 
    std::size_t
    size() const
    {
        return elements_.size();
    }
 
    int
    getIndex(SField const&) const;
 
    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 ripple
 
#endif