weakmap.h

#ifndef WEAKMAP_H
#define WEAKMAP_H

#include <map>
#include <set>
#include <vector>
#include <stdexcept>

#include <pv/sharedPtr.h>
#include <epicsMutex.h>
#include <epicsGuard.h>

template<typename K, typename V, typename C = std::less<K> >
class weak_value_map
{
public:
    typedef K key_type;
    typedef V value_type;
    typedef std::tr1::shared_ptr<V> value_pointer;
    typedef std::tr1::weak_ptr<V> value_weak_pointer;
    typedef std::set<value_pointer> set_type;

    typedef epicsMutex mutex_type;
    typedef epicsGuard<epicsMutex> guard_type;
    typedef epicsGuardRelease<epicsMutex> release_type;
private:
    typedef std::map<K, value_weak_pointer, C> store_t;

    struct data {
        mutex_type mutex;
        store_t store;
    };
    std::tr1::shared_ptr<data> _data;

    struct dtor {
        std::tr1::weak_ptr<data> container;
        K key;
        value_pointer realself;
        dtor(const std::tr1::weak_ptr<data>& d,
             const K& k,
             const value_pointer& w)
            :container(d), key(k), realself(w)
        {}
        void operator()(value_type *)
        {
            value_pointer R;
            R.swap(realself);
            std::tr1::shared_ptr<data> cont(container.lock());
            if(cont) {
                guard_type G(cont->mutex);
                cont->store.erase(key);
            }

            /* A subtle gotcha may exist since this struct
             * may not be destructed until the *weak*
             * count of the enclosing shared_ptr goes
             * to zero.  Which won't happen
             * as long as we hold a weak ref to the
             * container holding a weak ref to us.
             * It is *essential* that we break this
             * "weak ref. loop" explicitly
             */
            container.reset();
        }
    };
public:
    weak_value_map() :_data(new data) {}

private:
    weak_value_map(const weak_value_map& O);
    weak_value_map& operator=(const weak_value_map& O);
public:

    void swap(weak_value_map& O) {
        _data.swap(O._data);
    }

    void clear() {
        guard_type G(_data->mutex);
        return _data->store.clear();
    }

    bool empty() const {
        guard_type G(_data->mutex);
        return _data->store.empty();
    }

    size_t size() const {
        guard_type G(_data->mutex);
        return _data->store.size();
    }

    class element_proxy {
        weak_value_map& M;
        const key_type& k;
        friend class weak_value_map;
        element_proxy(weak_value_map& m, const key_type& k)
            :M(m), k(k) {}
    public:
        ~element_proxy() {}
        value_pointer& operator=(value_pointer& v)
        {
            if(!v.unique())
                throw std::invalid_argument("Only unique() references may be inserted");
            value_pointer chainptr(v.get(), dtor(M._data, k, v));
            M._data->store[k] = chainptr;
            v.swap(chainptr);
            return v;
        }
        inline V& operator*() const {
            return *value_pointer(*this);
        }
        inline V* operator->() const {
            return value_pointer(*this).get();
        }
        operator value_pointer() const
        {
            value_pointer ret = M.find(k);
            if(!ret)
                throw std::runtime_error("Bad key");
            return ret;
        }
        bool operator==(const value_pointer& v) const
        {
            return M.find(k)==v;
        }
        bool operator!=(const value_pointer& v) const
        {
            return !(*this==v);
        }
    };

    inline element_proxy operator[](const K& k)
    {
        return element_proxy(*this, k);
    }

    value_pointer operator[](const K& k) const
    {
        value_pointer ret = find(k);
        if(!ret)
            throw std::runtime_error("Bad key");
    }

    value_pointer find(const K& k) const
    {
        value_pointer ret;
        guard_type G(_data->mutex);
        typename store_t::const_iterator it(_data->store.find(k));
        if(it!=_data->store.end()) {
            // may be nullptr if we race destruction
            // as ref. count falls to zero before we can remove it
            ret = it->second.lock();
        }
        return ret;
    }

    value_pointer insert(const K& k, value_pointer& v)
    {
        value_pointer ret;
        guard_type G(_data->mutex);
        typename store_t::const_iterator it = _data->store.find(k);
        if(it!=_data->store.end())
            ret = it->second.lock();
        (*this)[k] = v;
        return ret;
    }

    typedef std::map<K, value_pointer, C> lock_map_type;
    lock_map_type lock_map() const
    {
        lock_map_type ret;
        guard_type G(_data->mutex);
        for(typename store_t::const_iterator it = _data->store.begin(),
            end = _data->store.end(); it!=end; ++it)
        {
            value_pointer P(it->second.lock);
            if(P) ret[it->first] = P;
        }
        return ret;
    }

    typedef std::vector<std::pair<K, value_pointer> > lock_vector_type;
    lock_vector_type lock_vector() const
    {
        lock_vector_type ret;
        guard_type G(_data->mutex);
        ret.reserve(_data->store.size());
        for(typename store_t::const_iterator it = _data->store.begin(),
            end = _data->store.end(); it!=end; ++it)
        {
            value_pointer P(it->second.lock());
            if(P) ret.push_back(std::make_pair(it->first, P));
        }
        return ret;
    }

    inline epicsMutex& mutex() const {
        return _data->mutex;
    }
};

#endif // WEAKMAP_H