Level.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_LEVEL_H
#define OGDF_LEVEL_H



#include <ogdf/basic/Graph.h>
#include <ogdf/basic/SList.h>
#include <ogdf/basic/tuples.h>


namespace ogdf {

class OGDF_EXPORT Hierarchy;

class LayerBasedUPRLayout;


template <class T = double>
class WeightComparer {
    const NodeArray<T> *m_pWeight;

public:
    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 {

    friend class Hierarchy;
    friend class LayerBasedUPRLayout;
    friend class HierarchyLayoutModule;

    Array<node> m_nodes;     
    Hierarchy *m_pHierarchy; 
    int m_index;             

public:

    Level(Hierarchy *pHierarchy, int index, int num) :
        m_nodes(num), m_pHierarchy(pHierarchy), m_index(index) { }

    // destruction
    ~Level() { }

    const node &operator[](int i) const { return m_nodes[i]; }
    node &operator[](int i) { return m_nodes[i]; }

    int size() const { return m_nodes.size(); }
    int high() const { return m_nodes.high(); }

    int index() const { return m_index; }

    const Array<node> &adjNodes(node v);

    const Hierarchy &hierarchy() const { return *m_pHierarchy; }

    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 ostream &operator<<(ostream &os, const Level &L) {
        os << L.m_nodes;
        return os;
    }

private:
    void getIsolatedNodes(SListPure<Tuple2<node,int> > &isolated);
    void setIsolatedNodes(SListPure<Tuple2<node,int> > &isolated);

    OGDF_MALLOC_NEW_DELETE
};

} // end namespace ogdf


#endif