paths.h

#pragma once
 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/JTx.h>
#include <test/jtx/amount.h>
 
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
 
#include <type_traits>
 
namespace xrpl {
class STPath;
 
namespace test::jtx {

class Paths
{
private:
    Asset in_;
    int depth_;
    unsigned int limit_;
 
public:
    Paths(Asset const& in, int depth = 7, unsigned int limit = 4)
        : in_(in), depth_(depth), limit_(limit)
    {
    }
 
    void
    operator()(Env&, JTx& jt) const;
};
 
//------------------------------------------------------------------------------

class Path
{
private:
    json::Value jv_;
 
public:
    Path();
 
    template <class T, class... Args>
    explicit Path(T const& t, Args const&... args);
 
    Path(STPath const& p);
 
    void
    operator()(Env&, JTx& jt) const;
 
private:
    json::Value&
    create();
 
    void
    appendOne(Account const& account);
 
    void
    appendOne(AccountID const& account);
 
    template <class T>
    void
    appendOne(T const& t)
        requires(std::is_constructible_v<Account, T>)
    {
        appendOne(Account{t});
    }
 
    void
    appendOne(IOU const& iou);
 
    void
    appendOne(BookSpec const& book);
 
    template <class T, class... Args>
    void
    append(T const& t, Args const&... args);
};
 
template <class T, class... Args>
Path::Path(T const& t, Args const&... args) : jv_(json::ValueType::Array)
{
    append(t, args...);
}
 
template <class T, class... Args>
void
Path::append(T const& t, Args const&... args)
{
    appendOne(t);
    if constexpr (sizeof...(args) > 0)
        append(args...);
}
 
}  // namespace test::jtx
 
}  // namespace xrpl