Consumer.cpp

#include <xrpl/basics/Log.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/resource/Charge.h>
#include <xrpl/resource/Consumer.h>
#include <xrpl/resource/Disposition.h>
#include <xrpl/resource/detail/Entry.h>
#include <xrpl/resource/detail/Logic.h>
 
#include <ostream>
#include <string>
 
namespace ripple {
namespace Resource {
 
Consumer::Consumer(Logic& logic, Entry& entry)
    : m_logic(&logic), m_entry(&entry)
{
}
 
Consumer::Consumer() : m_logic(nullptr), m_entry(nullptr)
{
}
 
Consumer::Consumer(Consumer const& other)
    : m_logic(other.m_logic), m_entry(nullptr)
{
    if (m_logic && other.m_entry)
    {
        m_entry = other.m_entry;
        m_logic->acquire(*m_entry);
    }
}
 
Consumer::~Consumer()
{
    if (m_logic && m_entry)
        m_logic->release(*m_entry);
}
 
Consumer&
Consumer::operator=(Consumer const& other)
{
    // remove old ref
    if (m_logic && m_entry)
        m_logic->release(*m_entry);
 
    m_logic = other.m_logic;
    m_entry = other.m_entry;
 
    // add new ref
    if (m_logic && m_entry)
        m_logic->acquire(*m_entry);
 
    return *this;
}
 
std::string
Consumer::to_string() const
{
    if (m_logic == nullptr)
        return "(none)";
 
    return m_entry->to_string();
}
 
bool
Consumer::isUnlimited() const
{
    if (m_entry)
        return m_entry->isUnlimited();
 
    return false;
}
 
Disposition
Consumer::disposition() const
{
    Disposition d = ok;
    if (m_logic && m_entry)
        d = m_logic->charge(*m_entry, Charge(0));
 
    return d;
}
 
Disposition
Consumer::charge(Charge const& what, std::string const& context)
{
    Disposition d = ok;
 
    if (m_logic && m_entry && !m_entry->isUnlimited())
        d = m_logic->charge(*m_entry, what, context);
 
    return d;
}
 
bool
Consumer::warn()
{
    XRPL_ASSERT(m_entry, "ripple::Resource::Consumer::warn : non-null entry");
    return m_logic->warn(*m_entry);
}
 
bool
Consumer::disconnect(beast::Journal const& j)
{
    XRPL_ASSERT(
        m_entry, "ripple::Resource::Consumer::disconnect : non-null entry");
    bool const d = m_logic->disconnect(*m_entry);
    if (d)
    {
        JLOG(j.debug()) << "disconnecting " << m_entry->to_string();
    }
    return d;
}
 
int
Consumer::balance()
{
    XRPL_ASSERT(
        m_entry, "ripple::Resource::Consumer::balance : non-null entry");
    return m_logic->balance(*m_entry);
}
 
Entry&
Consumer::entry()
{
    XRPL_ASSERT(m_entry, "ripple::Resource::Consumer::entry : non-null entry");
    return *m_entry;
}
 
void
Consumer::setPublicKey(PublicKey const& publicKey)
{
    m_entry->publicKey = publicKey;
}
 
std::ostream&
operator<<(std::ostream& os, Consumer const& v)
{
    os << v.to_string();
    return os;
}
 
}  // namespace Resource
}  // namespace ripple