ClusterSet.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/List.h>
#include <ogdf/cluster/ClusterArray.h>
 
namespace ogdf {
 
 
 
class OGDF_EXPORT ClusterSetSimple {
public:
    explicit ClusterSetSimple(const ClusterGraph& C) : m_isContained(C, false) { }
 
    // destructor
    ~ClusterSetSimple() { }
 
 
    void insert(cluster c) {
        OGDF_ASSERT(c->graphOf() == m_isContained.graphOf());
        bool& isContained = m_isContained[c];
        if (!isContained) {
            isContained = true;
            m_clusters.pushFront(c);
        }
    }
 
 
    void clear() {
        SListIterator<cluster> it;
        for (it = m_clusters.begin(); it.valid(); ++it) {
            m_isContained[*it] = false;
        }
        m_clusters.clear();
    }
 
 
    bool isMember(cluster c) const {
        OGDF_ASSERT(c->graphOf() == m_isContained.graphOf());
        return m_isContained[c];
    }
 
 
    const SListPure<cluster>& clusters() const { return m_clusters; }
 
private:
    ClusterArray<bool> m_isContained;
 
    SListPure<cluster> m_clusters;
};
 
 
class OGDF_EXPORT ClusterSetPure {
public:
    explicit ClusterSetPure(const ClusterGraph& C) : m_it(C, ListIterator<cluster>()) { }
 
    // destructor
    ~ClusterSetPure() { }
 
 
    void insert(cluster c) {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        ListIterator<cluster>& itV = m_it[c];
        if (!itV.valid()) {
            itV = m_clusters.pushBack(c);
        }
    }
 
 
    void remove(cluster c) {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        ListIterator<cluster>& itV = m_it[c];
        if (itV.valid()) {
            m_clusters.del(itV);
            itV = ListIterator<cluster>();
        }
    }
 
 
    void clear() {
        ListIterator<cluster> it;
        for (it = m_clusters.begin(); it.valid(); ++it) {
            m_it[*it] = ListIterator<cluster>();
        }
        m_clusters.clear();
    }
 
 
    bool isMember(cluster c) const {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        return m_it[c].valid();
    }
 
 
    const ListPure<cluster>& clusters() const { return m_clusters; }
 
private:
    ClusterArray<ListIterator<cluster>> m_it;
 
    ListPure<cluster> m_clusters;
};
 
 
class OGDF_EXPORT ClusterSet {
public:
    explicit ClusterSet(const ClusterGraph& C) : m_it(C, ListIterator<cluster>()) { }
 
    // destructor
    ~ClusterSet() { }
 
 
    void insert(cluster c) {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        ListIterator<cluster>& itV = m_it[c];
        if (!itV.valid()) {
            itV = m_clusters.pushBack(c);
        }
    }
 
 
    void remove(cluster c) {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        ListIterator<cluster>& itV = m_it[c];
        if (itV.valid()) {
            m_clusters.del(itV);
            itV = ListIterator<cluster>();
        }
    }
 
 
    void clear() {
        ListIterator<cluster> it;
        for (it = m_clusters.begin(); it.valid(); ++it) {
            m_it[*it] = ListIterator<cluster>();
        }
        m_clusters.clear();
    }
 
 
    bool isMember(cluster c) const {
        OGDF_ASSERT(c->graphOf() == m_it.graphOf());
        return m_it[c].valid();
    }
 
 
    int size() const { return m_clusters.size(); }
 
 
    const List<cluster>& clusters() const { return m_clusters; }
 
private:
    ClusterArray<ListIterator<cluster>> m_it;
 
    List<cluster> m_clusters;
};
 
}