Legacy/include/MultiSense/details/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);
        };
 
        //
        // Given that an insertion operation will happen, this function returns whether the
        // depth cache will drop a key, and if so, what the key that will be dropped is.
        //
        std::pair<bool, KEY> will_drop() {
            utility::ScopedLock lock(m_lock);
            return will_drop_();
        };
 
    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();
            }
        };
 
        std::pair<bool, KEY> will_drop_() {
            const bool will_drop = m_map.size() == m_depth;
            KEY drop_key; // If will_drop is false, this value is intentionally uninitialized
 
            if (will_drop)
            {
                drop_key = m_queue.back();
            }
            return std::pair<bool, KEY>(will_drop, drop_key);
        }
 
        const std::size_t m_depth;
        MapType           m_map;
        QueueType         m_queue;
        utility::Mutex    m_lock;
    };
 
}}} // namespaces
 
#endif // LibMultiSense_details_storage_hh