RegisteredSet.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/List.h>
#include <ogdf/basic/RegisteredArray.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/internal/copy_move.h>
 
namespace ogdf {
 
 
template<class Registry>
class RegisteredSet : private RegisteredObserver<Registry> {
    using Obs = RegisteredObserver<Registry>;
 
public:
    using registry_type = Registry;
    using element_type = typename Registry::key_type;
    using list_type = List<element_type>;
 
    explicit RegisteredSet(const Registry& R) : Obs(), m_it() {
        // parent constructor does not call registrationChanged callback
        // m_it.init called by registrationChanged callback from reregister
        Obs::reregister(&R);
    }
 
    explicit RegisteredSet(const Registry* R) : Obs(), m_it() { Obs::reregister(R); }
 
    explicit RegisteredSet() : Obs(), m_it() { }
 
    OGDF_COPY_CONSTR(RegisteredSet) : Obs(), m_it() { *this = copy; }
 
    OGDF_COPY_OP(RegisteredSet) {
        Obs::reregister(copy.registeredAt());
        // m_it.init and m_elements.clear called by registrationChanged callback
        for (element_type v : copy.elements()) {
            insert(v);
        }
        return *this;
    }
 
    OGDF_MOVE_CONSTR(RegisteredSet) { *this = std::move(move); }
 
    OGDF_MOVE_OP(RegisteredSet) {
        Obs::reregister(move.registeredAt());
        m_it = std::move(move.m_it);
        m_elements = std::move(move.m_elements);
        move.init();
        return *this;
    }
 
    void init() {
        // m_it.init and m_elements.clear called by registrationChanged callback
        Obs::reregister(nullptr);
    }
 
    void init(const Registry& R) { Obs::reregister(&R); }
 
 
    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 contains(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 Obs::getRegistry(); }
 
 
    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(); }
 
    friend bool operator==(const RegisteredSet& lhs, const RegisteredSet& rhs) {
        if (lhs.registeredAt() != rhs.registeredAt()) {
            return false;
        }
        if (lhs.size() != rhs.size()) {
            return false;
        }
        for (const auto& elem : lhs.elements()) {
            if (!rhs.isMember(elem)) {
                return false;
            }
        }
        return true;
    }
 
    friend bool operator!=(const RegisteredSet& lhs, const RegisteredSet& rhs) {
        return !(lhs == rhs);
    }
 
private:
    RegisteredArray<Registry, ListIterator<element_type>, false> m_it;
 
    list_type m_elements;
 
protected:
    void keyRemoved(typename Registry::key_type v) override { remove(v); }
 
    void keyAdded(typename Registry::key_type v) override { }
 
    void keysSwapped(int index1, int index2) override {
        OGDF_ASSERT(false); // RegisteredSets break on key swapping
    }
 
    void keysCopied(int toIndex, int fromIndex) override {
        OGDF_ASSERT(false); // RegisteredSets break on key copying
    }
 
    void keysCleared() override { clear(); }
 
    void registrationChanged(const Registry* old) override {
        m_it.init(Obs::getRegistry());
        m_elements.clear();
    }
};
 
}