Level.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory.h>
#include <ogdf/layered/CrossingMinInterfaces.h>
 
#include <iosfwd>
 
namespace ogdf {
 
class HierarchyLevels;
template<class E1, class E2>
class Tuple2;
template<class E>
class SListPure;
 
template<class T = double>
class WeightComparer {
    const NodeArray<T>* m_pWeight;
 
public:
    explicit WeightComparer(const NodeArray<T>* pWeight) : m_pWeight(pWeight) { }
 
    bool less(node v, node w) const { return (*m_pWeight)[v] < (*m_pWeight)[w]; }
 
    bool operator()(node v, node w) const { return (*m_pWeight)[v] < (*m_pWeight)[w]; }
};
 
 
class OGDF_EXPORT Level : public LevelBase {
    friend class HierarchyLevels;
    friend class HierarchyLayoutModule;
    friend class LayerBasedUPRLayout;
 
    Array<node> m_nodes; 
    HierarchyLevels* m_pLevels; 
    int m_index; 
 
public:
 
    Level(HierarchyLevels* pLevels, int index, int num)
        : m_nodes(num), m_pLevels(pLevels), m_index(index) { }
 
    // destruction
    ~Level() { }
 
    const node& operator[](int i) const override { return m_nodes[i]; }
 
    node& operator[](int i) override { return m_nodes[i]; }
 
    int size() const override { return m_nodes.size(); }
 
    int high() const override { return m_nodes.high(); }
 
    int index() const { return m_index; }
 
    const Array<node>& adjNodes(node v) const;
 
    const HierarchyLevels& levels() const { return *m_pLevels; }
 
    void swap(int i, int j);
 
    void sort(NodeArray<double>& weight);
 
    void sort(NodeArray<int>& weight, int minBucket, int maxBucket);
 
    void sortByWeightOnly(NodeArray<double>& weight);
 
    template<class C>
    void sortOrder(C& orderComparer) {
        m_nodes.quicksort(orderComparer);
        recalcPos();
    }
 
    void recalcPos();
 
    friend std::ostream& operator<<(std::ostream& os, const Level& L) {
        os << L.m_nodes;
        return os;
    }
 
private:
    void getIsolatedNodes(SListPure<Tuple2<node, int>>& isolated) const;
    void setIsolatedNodes(SListPure<Tuple2<node, int>>& isolated);
 
    OGDF_MALLOC_NEW_DELETE
};
 
}