storage.hh

Go to the documentation of this file.

#ifndef LibMultiSense_details_storage_hh
#define LibMultiSense_details_storage_hh

#include "MultiSense/details/utility/Thread.hh"

#include <map>
#include <deque>

namespace crl {
namespace multisense {
namespace details {

    //
    // A message storage interface
    //
    // Assumes a 1:1 relationship between template class and ID

    class MessageMap {
    public:

        template<class T> void store(const T& msg) {
            utility::ScopedLock lock(m_lock);

            Map::iterator it = m_map.find(MSG_ID(T::ID));
            if (m_map.end() != it) {
                it->second.destroy<T>();
                m_map.erase(it);
            }

            m_map[MSG_ID(T::ID)] = Holder::Create<T>(msg);
        }

        template<class T> Status extract(T& msg) {
            utility::ScopedLock lock(m_lock);

            Map::iterator it = m_map.find(MSG_ID(T::ID));
            if (m_map.end() == it)
                return Status_Error;

            it->second.extract(msg);
            m_map.erase(it);

            return Status_Ok;
        }

    private:

        class Holder {
        public:

            Holder(void *r=NULL) : m_refP(r) {};

            template<class T> static Holder Create(const T& msg) {
                return Holder(reinterpret_cast<void *>(new T(msg)));
            }

            template<class T> void destroy() {
                if (NULL == m_refP)
                    CRL_EXCEPTION("destroying NULL reference", "");
                delete reinterpret_cast<T*>(m_refP);
            }

            template<class T> void extract(T& msg) {
                if (NULL == m_refP)
                    CRL_EXCEPTION("extracting NULL reference", "");
                msg = *(reinterpret_cast<T*>(m_refP));
                destroy<T>();
            }

        private:
            void *m_refP;
        };

        typedef std::map<wire::IdType, Holder> Map;

        utility::Mutex m_lock;
        Map            m_map;
    };

    //
    // A constant-depth cache.
    //
    // Up to [depth] entries will be cached.  Oldest entries
    // will be dropped on insertion once full.
    //
    // The age of an entry is determined by std::map<KEY,DATA>.lower_bound([min]).
    //
    // DATA objects are assumed to be allocated on the heap, and memory management
    // of the object is delegated here upon insert().
    //
    // For *_nolock() variations, lock-management must be
    // done by the user.

    template<class KEY, class DATA>
    class DepthCache {
    public:

        DepthCache(std::size_t depth) :
            m_depth(depth) {};

        ~DepthCache() {
            utility::ScopedLock lock(m_lock);

            typename MapType::iterator it = m_map.begin();
            for(; it != m_map.end();) {
                delete it->second;
                m_map.erase(it++);
            }
        };

        utility::Mutex& mutex() {
            return m_lock;
        };

        DATA* find_nolock(KEY key) {
            return find_(key);
        };

        DATA* find(KEY key) {
            utility::ScopedLock lock(m_lock);
            return find_(key);
        };

        void insert_nolock(KEY key, DATA* data) {
            insert_(key, data);
        };

        void insert(KEY key, DATA* data) {
            utility::ScopedLock lock(m_lock);
            insert_(key, data);
        };

        void remove_nolock(KEY key) {
            remove_(key);
        };

        void remove(KEY key) {
            utility::ScopedLock lock(m_lock);
            remove_(key);
        };

    private:

        typedef std::deque<KEY> QueueType;
        typedef std::map<KEY,DATA*> MapType;

        DATA* find_(KEY key) {
            typename MapType::iterator it = m_map.find(key);

            if (m_map.end() == it)
                return NULL;
            else
                return it->second;
        };

        void insert_(KEY key, DATA* data) {
            if (m_map.size() == m_depth)
            {
                pop_oldest_();
            }

            typename MapType::iterator it = m_map.find(key);
            if (it == m_map.end()) {
                m_queue.push_front(key);
                m_map[key] = data;
            }
            else {
                delete it->second;
                it->second = data;
            }

        };

        void remove_(KEY key) {
            typename MapType::iterator it2 = m_map.find(key);
            if (m_map.end() != it2) {
                delete it2->second;
                m_map.erase(it2);
            }

            //assume we're erasing an older key, so search the order queue from the back
            for (typename QueueType::reverse_iterator it = m_queue.rbegin(); it != m_queue.rend();) {
                if (*it == key) {
                    m_queue.erase(--(it.base()));
                    break;
                }
                ++it;
            }
        };

        void pop_oldest_() {

            while (!m_queue.empty())
            {
                KEY k = m_queue.back();
                typename MapType::iterator it2 = m_map.find(k);
                if (m_map.end() != it2) {
                    delete it2->second;
                    m_map.erase(it2);
                    m_queue.pop_back();
                    break;
                }
                m_queue.pop_back();
            }
        };

        const std::size_t m_depth;
        MapType           m_map;
        QueueType         m_queue;
        utility::Mutex    m_lock;
    };

}}} // namespaces

#endif // LibMultiSense_details_storage_hh