STXChainBridge.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/STIssue.h>
#include <xrpl/protocol/Serializer.h>
 
#include <cstddef>
#include <memory>
#include <string>
#include <tuple>
 
namespace xrpl {
 
class Serializer;
class STObject;
 
class STXChainBridge final : public STBase, public CountedObject<STXChainBridge>
{
    STAccount lockingChainDoor_{sfLockingChainDoor};
    STIssue lockingChainIssue_{sfLockingChainIssue};
    STAccount issuingChainDoor_{sfIssuingChainDoor};
    STIssue issuingChainIssue_{sfIssuingChainIssue};
 
public:
    using value_type = STXChainBridge;
 
    enum class ChainType { Locking, Issuing };
 
    static ChainType
    otherChain(ChainType ct);
 
    static ChainType
    srcChain(bool wasLockingChainSend);
 
    static ChainType
    dstChain(bool wasLockingChainSend);
 
    STXChainBridge();
 
    explicit STXChainBridge(SField const& name);
 
    STXChainBridge(STXChainBridge const& rhs) = default;
 
    STXChainBridge(STObject const& o);
 
    STXChainBridge(
        AccountID const& srcChainDoor,
        Issue const& srcChainIssue,
        AccountID const& dstChainDoor,
        Issue const& dstChainIssue);
 
    explicit STXChainBridge(json::Value const& v);
 
    explicit STXChainBridge(SField const& name, json::Value const& v);
 
    explicit STXChainBridge(SerialIter& sit, SField const& name);
 
    STXChainBridge&
    operator=(STXChainBridge const& rhs) = default;
 
    [[nodiscard]] std::string
    getText() const override;
 
    [[nodiscard]] STObject
    toSTObject() const;
 
    [[nodiscard]] AccountID const&
    lockingChainDoor() const;
 
    [[nodiscard]] Issue const&
    lockingChainIssue() const;
 
    [[nodiscard]] AccountID const&
    issuingChainDoor() const;
 
    [[nodiscard]] Issue const&
    issuingChainIssue() const;
 
    [[nodiscard]] AccountID const&
    door(ChainType ct) const;
 
    [[nodiscard]] Issue const&
    issue(ChainType ct) const;
 
    [[nodiscard]] SerializedTypeID
    getSType() const override;
 
    [[nodiscard]] json::Value getJson(JsonOptions) const override;
 
    void
    add(Serializer& s) const override;
 
    [[nodiscard]] bool
    isEquivalent(STBase const& t) const override;
 
    [[nodiscard]] bool
    isDefault() const override;
 
    [[nodiscard]] value_type const&
    value() const noexcept;
 
private:
    static std::unique_ptr<STXChainBridge>
    construct(SerialIter&, SField const& name);
 
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend bool
    operator==(STXChainBridge const& lhs, STXChainBridge const& rhs);
 
    friend bool
    operator<(STXChainBridge const& lhs, STXChainBridge const& rhs);
};
 
inline bool
operator==(STXChainBridge const& lhs, STXChainBridge const& rhs)
{
    return std::tie(
               lhs.lockingChainDoor_,
               lhs.lockingChainIssue_,
               lhs.issuingChainDoor_,
               lhs.issuingChainIssue_) ==
        std::tie(
               rhs.lockingChainDoor_,
               rhs.lockingChainIssue_,
               rhs.issuingChainDoor_,
               rhs.issuingChainIssue_);
}
 
inline bool
operator<(STXChainBridge const& lhs, STXChainBridge const& rhs)
{
    return std::tie(
               lhs.lockingChainDoor_,
               lhs.lockingChainIssue_,
               lhs.issuingChainDoor_,
               lhs.issuingChainIssue_) <
        std::tie(
               rhs.lockingChainDoor_,
               rhs.lockingChainIssue_,
               rhs.issuingChainDoor_,
               rhs.issuingChainIssue_);
}
 
inline AccountID const&
STXChainBridge::lockingChainDoor() const
{
    return lockingChainDoor_.value();
};
 
inline Issue const&
STXChainBridge::lockingChainIssue() const
{
    return lockingChainIssue_.value().get<Issue>();
};
 
inline AccountID const&
STXChainBridge::issuingChainDoor() const
{
    return issuingChainDoor_.value();
};
 
inline Issue const&
STXChainBridge::issuingChainIssue() const
{
    return issuingChainIssue_.value().get<Issue>();
};
 
inline STXChainBridge::value_type const&
STXChainBridge::value() const noexcept
{
    return *this;
}
 
inline AccountID const&
STXChainBridge::door(ChainType ct) const
{
    if (ct == ChainType::Locking)
        return lockingChainDoor();
    return issuingChainDoor();
}
 
inline Issue const&
STXChainBridge::issue(ChainType ct) const
{
    if (ct == ChainType::Locking)
        return lockingChainIssue();
    return issuingChainIssue();
}
 
inline STXChainBridge::ChainType
STXChainBridge::otherChain(ChainType ct)
{
    if (ct == ChainType::Locking)
        return ChainType::Issuing;
    return ChainType::Locking;
}
 
inline STXChainBridge::ChainType
STXChainBridge::srcChain(bool wasLockingChainSend)
{
    if (wasLockingChainSend)
        return ChainType::Locking;
    return ChainType::Issuing;
}
 
inline STXChainBridge::ChainType
STXChainBridge::dstChain(bool wasLockingChainSend)
{
    if (wasLockingChainSend)
        return ChainType::Issuing;
    return ChainType::Locking;
}
 
}  // namespace xrpl