WeakPtrCache.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_WeakPtrCache_h
#define yap_WeakPtrCache_h

#include <algorithm>
#include <memory>
#include <ostream>
#include <set>
#include <string>

namespace yap {


template <class T>
class WeakPtrCache
{
public:


    using type = T;

    using shared_ptr_type = std::shared_ptr<T>;

    using weak_ptr_type = std::weak_ptr<T>;

    using cache_type = std::set<weak_ptr_type, std::owner_less<weak_ptr_type> >;


    virtual bool equal(const shared_ptr_type& A, const shared_ptr_type& B) const = 0;


    WeakPtrCache() = default;

    WeakPtrCache(const WeakPtrCache&) = default;

    WeakPtrCache(WeakPtrCache&&) = default;

    WeakPtrCache(std::vector<shared_ptr_type> V)
    { for (auto& v : V) operator[](v); }

    virtual ~WeakPtrCache() = default;

    WeakPtrCache& operator=(const WeakPtrCache&) = default;

    WeakPtrCache& operator=(WeakPtrCache&&) = default;


    weak_ptr_type find(shared_ptr_type t) const
    {
        if (!t)
            return weak_ptr_type();

        // search for equivalent
        auto it = std::find_if(Cache_.begin(), Cache_.end(), [&](const weak_ptr_type & w) {return !w.expired() and equal(w.lock(), t);});

        if (it == Cache_.end())
            // if not found
            return weak_ptr_type();

        return *it;
    }

    shared_ptr_type operator[](shared_ptr_type t)
    {
        auto w = find(t);

        // if w is valid (t is found in cache)
        if (!w.expired())
            return w.lock();

        // else add to cache
        addToCache(t);
        return t;
    }

    bool empty() const
    { return Cache_.empty(); }

    size_t size() const
    { return Cache_.size(); }

    size_t count_expired() const
    { return std::count_if(Cache_.begin(), Cache_.end(), [](const weak_ptr_type & w) {return w.expired();}); }

    void removeExpired()
    {
        for (auto it = Cache_.begin(); it != Cache_.end(); ) {
            if (it->expired())
                it = Cache_.erase(it);
            else
                it++;
        }
    }


    typename cache_type::iterator begin()
    { return Cache_.begin(); }

    typename cache_type::const_iterator begin() const
    { return Cache_.begin(); }

    typename cache_type::iterator end()
    { return Cache_.end(); }

    typename cache_type::const_iterator end() const
    { return Cache_.end(); }


    virtual std::ostream& print(std::ostream& os) const
    {
        for (auto& w : *this)
            if (!w.expired())
                os << *w.lock() << std::endl;
        return os;
    }

protected:

    virtual void addToCache(shared_ptr_type t)
    { Cache_.emplace(t); }

private:

    cache_type Cache_;

};

template <class T>
inline std::ostream& operator<<(std::ostream& os, const WeakPtrCache<T>& C)
{
    os << "contains " << C.size() << " elements, of which "
       << C.count_expired() << " have expired" << std::endl;

    return C.print(os);
}

}

#endif