SharedPairMap.hpp

Go to the documentation of this file.

#ifndef _IDENTT_UTILS_SHARED_PAIR_MAP_HPP_
#define _IDENTT_UTILS_SHARED_PAIR_MAP_HPP_

#include <unordered_map>
#include <utility>
#include <functional>
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>

namespace identt {
namespace utils {
template<class KeyT,class LeftT,class RightT>
class SharedPairMap {
public:
    using ValueT = std::pair<LeftT,RightT>;
    using PairMapT = std::unordered_map<KeyT,ValueT>;
    using LockT = boost::shared_mutex;
    using WriteLockT = boost::unique_lock< LockT >;
    using ReadLockT = boost::shared_lock< LockT >;

    SharedPairMap(const SharedPairMap&) = delete;
    SharedPairMap& operator=(const SharedPairMap&) = delete;

    SharedPairMap() {}

    virtual ~SharedPairMap () {}

    void AddOne(KeyT key, ValueT value)
    {
        WriteLockT writelock(mutex_);
        t_[key]=value;
    }

    void AddLeft(KeyT key, LeftT value)
    {
        WriteLockT writelock(mutex_);
        typename PairMapT::iterator it = t_.find(key);
        if (it!=t_.end()) it.second.first = value;
        else t_[key]=std::make_pair(value,RightT());
    }

    void AddRight(KeyT key, RightT value)
    {
        WriteLockT writelock(mutex_);
        typename PairMapT::iterator it = t_.find(key);
        if (it!=t_.end()) it.second.second = value;
        else t_[key]=std::make_pair(LeftT(),value);
    }

    void Swap(PairMapT m)
    {
        WriteLockT writelock(mutex_);
        t_.swap(m);
    }

    void AddMany(const PairMapT& m)
    {
        WriteLockT writelock(mutex_);
        for (auto& p : m) {
            t_[p.first]=p.second;
        }
    }

    void AddMany(PairMapT&& m)
    {
        WriteLockT writelock(mutex_);
        for (auto& p : m) {
            t_[p.first]=p.second;
        }
    }

    bool GetValues(KeyT&& key, LeftT& left, RightT& right)
    {
        ReadLockT readlock(mutex_);
        typename PairMapT::const_iterator it = t_.find(key);
        bool stat = (it!=t_.end());
        left= stat ? it.second.first : LeftT();
        right= stat ? it.second.second : RightT();
        return stat;
    }

    bool GetValues(const KeyT& key, LeftT& left, RightT& right)
    {
        ReadLockT readlock(mutex_);
        typename PairMapT::const_iterator it = t_.find(key);
        bool stat = (it!=t_.end());
        left= stat ? it.second.first : LeftT();
        right= stat ? it.second.second : RightT();
        return stat;
    }

    PairMapT GetCopy()
    {
        ReadLockT readlock(mutex_);
        return t_;
    }

    size_t GetSize()
    {
        ReadLockT readlock(mutex_);
        return t_.size();
    }

    void Reset()
    {
        WriteLockT writelock(mutex_);
        t_.clear();
    }


protected:
    PairMapT t_;
    LockT mutex_;

};
} // namespace utils
} // namespace identt
#endif /* _IDENTT_UTILS_SHARED_PAIR_MAP_HPP_ */