doubleMap.hpp

Go to the documentation of this file.

 
#ifndef RAD_DOUBLE_MAP_HPP
#define RAD_DOUBLE_MAP_HPP
 
#include <string>
#include <map>
#include <mutex>
 
namespace rad {
 
 
template <typename T>
class DoubleMap {
public:
    DoubleMap() : m_kv_write_index(0) {
    }
 
    virtual ~DoubleMap() {}
 
    void Reset() {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_kv[0].clear();
        m_kv[1].clear();
        m_kv_write_index = 0;
    }
 
    void Set(const std::string& key, const T& value) {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_kv[m_kv_write_index][key] = value;
    }
 
    void Set(const std::map<std::string, T>& kv_map) {
        std::lock_guard<std::mutex> lock(m_mutex);
        for(auto& kv : kv_map) {
            m_kv[m_kv_write_index][kv.first] = kv.second;
        }
    }
 
    void Pop(std::map<std::string, T>& kv_map) {
        /*
         * Swap read/write maps.
         */
        int kv_read_index = m_kv_write_index;
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (m_kv_write_index == 0) {
                m_kv_write_index = 1;
            } else {
                m_kv_write_index = 0;
            }
        }
 
        /*
         * Copy the key/value pairs.
         */
        kv_map = m_kv[kv_read_index];
 
        /*
         * Clear the buffer to avoid returning again old
         * attributes/values already processed by the
         * consumer.
         */
        m_kv[kv_read_index].clear();
    }
 
    DoubleMap(const DoubleMap&) = delete;
 
    DoubleMap& operator=(const DoubleMap&) = delete;
 
private:
    std::mutex m_mutex;  
    std::map<std::string, T> m_kv[2];  
    int m_kv_write_index;  
};
 
}  // namespace rad
 
#endif  // RAD_DOUBLE_MAP_HPP