MemoryListener.h

Go to the documentation of this file.

#pragma once
 
// STD/STL
#include <functional>
#include <mutex>
#include <unordered_map>
#include <vector>
 
// RobotAPI
#include <RobotAPI/interface/armem/client/MemoryListenerInterface.h>
#include <RobotAPI/libraries/armem/core/MemoryID.h>
 
#include "SubscriptionHandle.h"
 
namespace armarx
{
    class ManagedIceObject;
}
 
namespace armarx::armem::client::util
{
    /**
     * @brief Handles update signals from the memory system and distributes it
     * to its subsribers.
     */
    class MemoryListener
    {
 
    public:
        using Callback = std::function<void(const MemoryID& subscriptionID,
                                            const std::vector<MemoryID>& updatedSnapshotIDs)>;
        using CallbackUpdatedOnly =
            std::function<void(const std::vector<MemoryID>& updatedSnapshotIDs)>;
 
        template <class CalleeT>
        using MemberCallback = void (CalleeT::*)(const MemoryID& subscriptionID,
                                                 const std::vector<MemoryID>& updatedSnapshotIDs);
        template <class CalleeT>
        using MemberCallbackUpdatedOnly =
            void (CalleeT::*)(const std::vector<MemoryID>& updatedSnapshotIDs);
 
        static std::string MakeMemoryTopicName(const MemoryID& memoryID);
 
 
    public:
        MemoryListener(ManagedIceObject* component = nullptr);
 
        void setComponent(ManagedIceObject* component);
 
        SubscriptionHandle subscribe(const MemoryID& subscriptionID, Callback Callback);
        SubscriptionHandle subscribe(const MemoryID& subscriptionID, CallbackUpdatedOnly Callback);
 
        /**
         * Subscribe with a class member function:
         * @code
         * listener.subscribe(entityID, this, &This::myCallback);
         * @endcode
         */
        template <class CalleeT>
        SubscriptionHandle
        subscribe(const MemoryID& subscriptionID, CalleeT* callee, MemberCallback<CalleeT> callback)
        {
            auto cb = [callee, callback](const MemoryID& subscriptionID,
                                         const std::vector<MemoryID>& updatedSnapshotIDs)
            { (callee->*callback)(subscriptionID, updatedSnapshotIDs); };
            return subscribe(subscriptionID, cb);
        }
 
        template <class CalleeT>
        SubscriptionHandle
        subscribe(const MemoryID& subscriptionID,
                  CalleeT* callee,
                  MemberCallbackUpdatedOnly<CalleeT> callback)
        {
            auto cb =
                [callee, callback](const MemoryID&, const std::vector<MemoryID>& updatedSnapshotIDs)
            {
                if (callee)
                {
                    (callee->*callback)(updatedSnapshotIDs);
                }
            };
            return subscribe(subscriptionID, cb);
        }
 
        void unsubscribe(SubscriptionHandle& subscriptionHandle);
 
        /// Function handling updates from the MemoryListener ice topic.
        void updated(const std::vector<MemoryID>& updatedIDs) const;
        void updated(const std::vector<data::MemoryID>& updatedIDs) const;
 
 
    protected:
        long nextId = 0;
 
        struct ManagedCallback
        {
            long id = 0;
            Callback callback;
        };
 
        mutable std::mutex subscribeMutex;
        std::unordered_map<MemoryID, std::vector<ManagedCallback>> callbacks;
 
        /// memoryName -> #callbacks needing memory topic
        std::unordered_map<std::string, int> memoryRefCount;
 
    private:
        armarx::ManagedIceObject* component;
    };
 
} // namespace armarx::armem::client::util