RegisteredSet.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/List.h>
#include <ogdf/basic/RegisteredArray.h>
 
#include <type_traits>
 
namespace ogdf {
 
 
template<class Registry, bool SupportFastSizeQuery = true>
class RegisteredSet {
public:
    using element_type = typename Registry::key_type;
    using list_type = typename std::conditional<SupportFastSizeQuery, List<element_type>,
            ListPure<element_type>>::type;
 
    explicit RegisteredSet(const Registry& R) : m_it(&R) { }
 
    explicit RegisteredSet() : m_it() { }
 
    void init() {
        m_it.init();
        m_elements.clear();
    }
 
    void init(const Registry& R) {
        m_it.init(&R);
        m_elements.clear();
    }
 
 
    void insert(element_type v) {
        ListIterator<element_type>& itV = m_it[v];
        if (!itV.valid()) {
            itV = m_elements.pushBack(v);
        }
    }
 
 
    bool remove(element_type v) {
        ListIterator<element_type>& itV = m_it[v];
        if (itV.valid()) {
            m_elements.del(itV);
            itV = ListIterator<element_type>();
            return true;
        } else {
            return false;
        }
    }
 
 
    void clear() {
        if (!registeredAt()) {
            return;
        }
        if (size() * 10 < registeredAt()->getArraySize()) {
            while (!m_elements.empty()) {
                remove(m_elements.front());
            }
        } else {
            m_it.fill(ListIterator<element_type>());
            m_elements.clear();
        }
    }
 
 
    bool isMember(element_type v) const { return m_it[v].valid(); }
 
    bool operator()(element_type v) const { return isMember(v); }
 
    const list_type& elements() const { return m_elements; }
 
    const Registry* registeredAt() const { return m_it.registeredAt(); }
 
 
    int size() const { return m_elements.size(); }
 
    typename list_type::const_iterator begin() const { return m_elements.begin(); }
 
    typename list_type::const_iterator end() const { return m_elements.end(); }
 
    template<bool OtherSupportsFastSizeQuery>
    explicit RegisteredSet(const RegisteredSet<Registry, OtherSupportsFastSizeQuery>& other) {
        this = other;
    }
 
    template<bool OtherSupportsFastSizeQuery>
    RegisteredSet& operator=(const RegisteredSet<Registry, OtherSupportsFastSizeQuery>& other) {
        m_elements.clear();
        m_it.init(other.registeredAt());
        for (element_type v : other.elements()) {
            insert(v);
        }
    }
 
private:
    RegisteredArray<Registry, ListIterator<element_type>, false> m_it;
 
    list_type m_elements;
};
 
}