Tracker.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.
 
 
 
 
#ifndef Sawyer_Container_Tracker_H
#define Sawyer_Container_Tracker_H
 
#include <Sawyer/Set.h>
#include <Sawyer/Synchronization.h>
 
namespace Sawyer {
namespace Container {
 
template<class Key>
class TrackerSetIndex {
    Set<Key> set;
public:
    void clear() {
        set.clear();
    }
    bool exists(const Key &key) const {
        return set.exists(key);
    }
    bool insert(const Key &key) {
        return set.insert(key);
    }
};
 
template<class Key>
class TrackerVectorIndex {
    std::vector<bool> bvec;
public:
    void clear() {
        bvec.clear();
    }
    bool exists(const Key &key) const {
        return key < bvec.size() && bvec[key];
    }
    bool insert(const Key &key) {
        bool retval = !exists(key);
        if (key >= bvec.size())
            bvec.resize(key+1, false);
        bvec[key] = true;
        return retval;
    }
};
 
template<class Key>
class TrackerUnorderedIndex {
    boost::unordered_set<Key> set;
public:
    void clear() {
        set.clear();
    }
    bool exists(const Key &key) const {
        return set.find(key) != set.end();
    }
    bool insert(const Key &key) {
        return set.insert(key).second;
    }
};
 
template<class Key>
struct TrackerTraits {
    typedef TrackerSetIndex<Key> Index;
};
 
template<class T, class K = T, class Traits = TrackerTraits<K> >
class Tracker {
public:
    typedef T Value;
 
    typedef K Key;
 
private:
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_;         // protects the following data members.
    typename Traits::Index index_;
 
public:
    void clear() {
        SAWYER_THREAD_TRAITS::LockGuard lock(mutex_);
        index_.clear();
    }
 
    bool testAndSet(const Value &value) {
        Key key(value);
        SAWYER_THREAD_TRAITS::LockGuard lock(mutex_);
        return !index_.insert(key);
    }
 
    bool operator()(const Value &value) {
        return testAndSet(value);
    }
 
    bool wasSeen(const Value &value) const {
        Key key(value);
        SAWYER_THREAD_TRAITS::LockGuard lock(mutex_);
        return index_.exists(key);
    }
 
    bool insert(const Value &value) {
        return !testAndSet(value);
    }
 
    void removeIfSeen(std::vector<Value> &vector) {
        size_t nSaved = 0;
        for (size_t i = 0; i < vector.size(); ++i) {
            if (insert(vector[i]))
                vector[nSaved++] = vector[i];
        }
        vector.resize(nSaved);
    }
};
 
} // namespace
} // namespace
 
#endif