SubscriptionHandle.cpp

Go to the documentation of this file.

#include "SubscriptionHandle.h"
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "MemoryListener.h"
 
namespace armarx::armem::client::util
{
    SubscriptionHandle::SubscriptionHandle(MemoryListener* memoryListener,
                                           const MemoryID& memoryID,
                                           long id) :
        valid{true}, memoryListener{memoryListener}, memoryID(memoryID), id{id}
    {
    }
 
    SubscriptionHandle::SubscriptionHandle() : valid{false}
    {
    }
 
    SubscriptionHandle::SubscriptionHandle(SubscriptionHandle&& other) :
        valid{other.valid},
        memoryListener{other.memoryListener},
        memoryID(std::move(other.memoryID)),
        id{other.id}
    {
        other.valid = false;
    }
 
    SubscriptionHandle&
    SubscriptionHandle::operator=(SubscriptionHandle other)
    {
        swap(*this, other);
        return *this;
    }
 
    void
    SubscriptionHandle::release()
    {
        if (memoryListener != nullptr)
        {
            memoryListener->unsubscribe(*this);
        }
    }
 
    ScopedSubscriptionHandle::ScopedSubscriptionHandle()
    {
    }
 
    ScopedSubscriptionHandle::ScopedSubscriptionHandle(SubscriptionHandle&& handle) :
        handle(std::move(handle))
    {
    }
 
    ScopedSubscriptionHandle&
    ScopedSubscriptionHandle::operator=(SubscriptionHandle handle)
    {
        std::swap(this->handle, handle);
        return *this;
    }
 
    ScopedSubscriptionHandle::~ScopedSubscriptionHandle()
    {
        ARMARX_INFO << "Releasing handle";
        handle.release();
    }
 
} // namespace armarx::armem::client::util
 
namespace armarx::armem::client
{
    void
    util::swap(util::SubscriptionHandle& first, util::SubscriptionHandle& second)
    {
        std::swap(first.valid, second.valid);
        std::swap(first.memoryListener, second.memoryListener);
        std::swap(first.memoryID, second.memoryID);
        std::swap(first.id, second.id);
    }
} // namespace armarx::armem::client