UintTypes.h

#ifndef XRPL_PROTOCOL_UINTTYPES_H_INCLUDED
#define XRPL_PROTOCOL_UINTTYPES_H_INCLUDED
 
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/protocol/AccountID.h>
 
namespace ripple {
namespace detail {
 
class CurrencyTag
{
public:
    explicit CurrencyTag() = default;
};
 
class DirectoryTag
{
public:
    explicit DirectoryTag() = default;
};
 
class NodeIDTag
{
public:
    explicit NodeIDTag() = default;
};
 
}  // namespace detail
 
using Directory = base_uint<256, detail::DirectoryTag>;
 
using Currency = base_uint<160, detail::CurrencyTag>;
 
using NodeID = base_uint<160, detail::NodeIDTag>;
 
using MPTID = base_uint<192>;
 
using Domain = base_uint<256>;
 
Currency const&
xrpCurrency();
 
Currency const&
noCurrency();
 
Currency const&
badCurrency();
 
inline bool
isXRP(Currency const& c)
{
    return c == beast::zero;
}
 
std::string
to_string(Currency const& c);
 
bool
to_currency(Currency&, std::string const&);
 
Currency
to_currency(std::string const&);
 
inline std::ostream&
operator<<(std::ostream& os, Currency const& x)
{
    os << to_string(x);
    return os;
}
 
}  // namespace ripple
 
namespace std {
 
template <>
struct hash<ripple::Currency> : ripple::Currency::hasher
{
    hash() = default;
};
 
template <>
struct hash<ripple::NodeID> : ripple::NodeID::hasher
{
    hash() = default;
};
 
template <>
struct hash<ripple::Directory> : ripple::Directory::hasher
{
    hash() = default;
};
 
template <>
struct hash<ripple::uint256> : ripple::uint256::hasher
{
    hash() = default;
};
 
}  // namespace std
 
#endif