weakset.h

#ifndef WEAKSET_H
#define WEAKSET_H

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

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

template<typename T>
class weak_set
{
public:
    typedef T value_type;
    typedef std::tr1::shared_ptr<T> value_pointer;
    typedef std::tr1::weak_ptr<T> value_weak_pointer;
    typedef std::set<value_pointer> set_type;
    typedef std::vector<value_pointer> vector_type;

    typedef epicsMutex mutex_type;
    typedef epicsGuard<epicsMutex> guard_type;
    typedef epicsGuardRelease<epicsMutex> release_type;
private:
    struct weak_less {
        bool operator()(const value_weak_pointer& lhs,
                        const value_weak_pointer& rhs) const
        {
            value_pointer LHS(lhs.lock()), RHS(rhs.lock());
            return LHS && RHS && LHS.get() < RHS.get();
        }
        bool operator()(const value_pointer& lhs,
                        const value_weak_pointer& rhs) const
        {
            value_pointer RHS(rhs.lock());
            return RHS && lhs.get() < RHS.get();
        }
        bool operator()(const value_weak_pointer& lhs,
                        const value_pointer& rhs) const
        {
            value_pointer LHS(lhs.lock());
            return LHS && LHS.get() < rhs.get();
        }
    };

    typedef std::set<value_weak_pointer, weak_less> store_t;

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

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

            /* 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_set() :_data(new data) {}

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

    void swap(weak_set& 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();
    }

    void insert(value_pointer&);

    size_t erase(value_pointer& v) {
        guard_type G(_data->mutex);
        return _data->store.erase(v);
    }

    set_type lock_set() const;

    vector_type lock_vector() const;

    void lock_vector(vector_type&) const;

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

    struct XIterator {
        weak_set& set;
        epicsGuard<epicsMutex> guard;
        typename store_t::iterator it, end;
        XIterator(weak_set& S) :set(S), guard(S.mutex()), it(S._data->store.begin()), end(S._data->store.end()) {}
        value_pointer next() {
            value_pointer ret;
            while(it!=end) {
                ret = (it++)->lock();
                if(ret) break;
            }
            return ret;
        }
    private:
        XIterator(const XIterator&);
        XIterator& operator=(const XIterator&);
    };

    typedef XIterator iterator;
};

template<typename T>
void weak_set<T>::insert(value_pointer &v)
{
    if(!v.unique())
        throw std::invalid_argument("Only unique() references may be inserted");

    guard_type G(_data->mutex);
    typename store_t::const_iterator it = _data->store.find(v);
    if(it==_data->store.end()) { // new object

        // wrapped strong ref. which removes from our map
        value_pointer chainptr(v.get(), dtor(_data, v));

        _data->store.insert(chainptr);

        v.swap(chainptr); // we only keep the chained pointer
    } else {
        // already stored, no-op

        // paranoia, if already inserted then this should be a wrapped ref.
        // but not sure how to check this so update arg. with known wrapped ref.
        v = value_pointer(*it); // could throw bad_weak_ptr, but really never should
    }
}

template<typename T>
typename weak_set<T>::set_type
weak_set<T>::lock_set() const
{
    set_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->lock());
        if(P) ret.insert(P);
    }
    return ret;
}

template<typename T>
typename weak_set<T>::vector_type
weak_set<T>::lock_vector() const
{
    vector_type ret;
    lock_vector(ret);
    return ret;
}

template<typename T>
void weak_set<T>::lock_vector(vector_type& ret) const
{
    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->lock());
        if(P) ret.push_back(P);
    }
}

#endif // WEAKSET_H