QPartitioning.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/List.h>
#include <ogdf/basic/basic.h>
 
namespace ogdf::sync_plan {
class QPartitioning; // IWYU pragma: keep
 
#define OGDF_DECL_REG_ARRAY_TYPE(v, c) RegisteredArray<QPartitioning, v, c>
OGDF_DECL_REG_ARRAY(PartitionArray)
#undef OGDF_DECL_REG_ARRAY_TYPE
 
class OGDF_EXPORT QPartitioning : protected GraphObserver,
                                  public RegistryBase<int, QPartitioning, int> {
private:
    PartitionArray<List<node>> partitioned_nodes;
    NodeArray<int> partitions;
    int q_vertex_count = 0;
    int partition_next_id = 0;
 
public:
    static inline int NO_PARTITION = -1;
 
    explicit QPartitioning(const Graph* G) : GraphObserver(G), partitions(*G, NO_PARTITION) {
        partitioned_nodes.init(*this);
    }
 
    bool isQVertex(node n) const;
 
    int getPartitionOf(node n) const;
 
    int makeQVertex(node n, int p = NO_PARTITION);
 
    void releaseQVertex(node n);
 
    int partitionCount() const { return partition_next_id; }
 
    int qVertexCount() const { return q_vertex_count; }
 
    const List<node>& nodesInPartition(int partition) const { return partitioned_nodes[partition]; }
 
    static inline int keyToIndex(int key) { return key; }
 
    bool isKeyAssociated(int key) const { return 0 <= key && key <= maxKeyIndex(); }
 
    int maxKeyIndex() const { return partition_next_id - 1; }
 
    int calculateArraySize(int add) const { return calculateTableSize(partition_next_id + add); }
 
    int begin() const { return 0; }
 
    int end() const { return partition_next_id; }
 
protected:
    void nodeDeleted(node v) override;
 
    void nodeAdded(node v) override {};
 
    void edgeDeleted(edge e) override {};
 
    void edgeAdded(edge e) override {};
 
    void cleared() override {
        partitioned_nodes.fillWithDefault();
        partitions.fill(NO_PARTITION);
        q_vertex_count = 0;
        partition_next_id = 0;
    };
};
}