SeqProxy.h

#ifndef XRPL_PROTOCOL_SEQ_PROXY_H_INCLUDED
#define XRPL_PROTOCOL_SEQ_PROXY_H_INCLUDED
 
#include <cstdint>
#include <ostream>
 
namespace ripple {
 
class SeqProxy
{
public:
    enum Type : std::uint8_t { seq = 0, ticket };
 
private:
    std::uint32_t value_;
    Type type_;
 
public:
    constexpr explicit SeqProxy(Type t, std::uint32_t v) : value_{v}, type_{t}
    {
    }
 
    SeqProxy(SeqProxy const& other) = default;
 
    SeqProxy&
    operator=(SeqProxy const& other) = default;
 
    static constexpr SeqProxy
    sequence(std::uint32_t v)
    {
        return SeqProxy{Type::seq, v};
    }
 
    constexpr std::uint32_t
    value() const
    {
        return value_;
    }
 
    constexpr bool
    isSeq() const
    {
        return type_ == seq;
    }
 
    constexpr bool
    isTicket() const
    {
        return type_ == ticket;
    }
 
    // Occasionally it is convenient to be able to increase the value_
    // of a SeqProxy.  But it's unusual.  So, rather than putting in an
    // addition operator, you must invoke the method by name.  That makes
    // if more difficult to invoke accidentally.
    SeqProxy&
    advanceBy(std::uint32_t amount)
    {
        value_ += amount;
        return *this;
    }
 
    // Comparison
    //
    // The comparison is designed specifically so _all_ Sequence
    // representations sort in front of Ticket representations.  This
    // is true even if the Ticket value() is less that the Sequence
    // value().
    //
    // This somewhat surprising sort order has benefits for transaction
    // processing.  It guarantees that transactions creating Tickets are
    // sorted in from of transactions that consume Tickets.
    friend constexpr bool
    operator==(SeqProxy lhs, SeqProxy rhs)
    {
        if (lhs.type_ != rhs.type_)
            return false;
        return (lhs.value() == rhs.value());
    }
 
    friend constexpr bool
    operator!=(SeqProxy lhs, SeqProxy rhs)
    {
        return !(lhs == rhs);
    }
 
    friend constexpr bool
    operator<(SeqProxy lhs, SeqProxy rhs)
    {
        if (lhs.type_ != rhs.type_)
            return lhs.type_ < rhs.type_;
        return lhs.value() < rhs.value();
    }
 
    friend constexpr bool
    operator>(SeqProxy lhs, SeqProxy rhs)
    {
        return rhs < lhs;
    }
 
    friend constexpr bool
    operator>=(SeqProxy lhs, SeqProxy rhs)
    {
        return !(lhs < rhs);
    }
 
    friend constexpr bool
    operator<=(SeqProxy lhs, SeqProxy rhs)
    {
        return !(lhs > rhs);
    }
 
    friend std::ostream&
    operator<<(std::ostream& os, SeqProxy seqProx)
    {
        os << (seqProx.isSeq() ? "sequence " : "ticket ");
        os << seqProx.value();
        return os;
    }
};
}  // namespace ripple
 
#endif