*** empty log message ***

[lilypond.git] / flower / include / pqueue.hh

diff --git a/flower/include/pqueue.hh b/flower/include/pqueue.hh
index 5f4a97fb4792c1d8bd660fbc822cfa310c403272..d7a8375fcbb102238eef5656639d989578b7f60f 100644 (file)
--- a/flower/include/pqueue.hh
+++ b/flower/include/pqueue.hh
@@ -3,13 +3,13 @@
 
   source file of the Flower Library
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+  (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 
 
 #ifndef PQUEUE_HH
 #define PQUEUE_HH
-#include "varray.hh"
+#include "array.hh"
 
 
 template<class K, class T>
@@ -30,36 +30,36 @@ int compare (PQueue_ent<K,T> const &e1 , PQueue_ent<K,T> const &e2) {
   Hungarian postfix pq
   
   TODO: add increase/decrease operations,
-  add max() operation
+  add max () operation
  */
 template<class T>
 class PQueue {
-    Array<T> heap_arr_;
+    Array<T> heap_array_;
     T &elt (int i) {
-       return heap_arr_[i-1];
+       return heap_array_[i-1];
     }
     T const&elt (int i) const {
-       return heap_arr_[i-1];
+       return heap_array_[i-1];
     }
 public:
     /** acces an heap element.  Careful with this, as changing the
       priority might fuck up the invariants
 
-      @param 1 <= i < size() */
-    T& operator[](int i) { return heap_arr_[i]; }
-    T operator[](int i) const { return heap_arr_[i]; }
-    void OK() const
+      @param 1 <= i < size () */
+    T& operator[] (int i) { return heap_array_[i]; }
+    T operator[] (int i) const { return heap_array_[i]; }
+    void OK () const
     {
 #ifndef NDEBUG
-       for (int i =2; i <= size(); i++)
+       for (int i =2; i <= size (); i++)
            assert (compare (elt (i/2), elt (i)) <= 0);
 #endif
     }
-    T front() const { return elt (1); }
-    int size() const { return heap_arr_.size (); }
+    T front () const { return elt (1); }
+    int size () const { return heap_array_.size (); }
     void insert (T v) {
-       heap_arr_.push (v);
-       int i = heap_arr_.size();
+       heap_array_.push (v);
+       int i = heap_array_.size ();
        int j = i / 2 ;
        while (j) {
            if (compare (elt (j), v) > 0) {
@@ -71,21 +71,21 @@ public:
            }
        }
        elt (i) = v;
-       OK();
+       OK ();
     }
-    T max() const {
-       //int first_leaf_i = size();
+    T max () const {
+       //int first_leaf_i = size ();
        T max_t;
        return max_t;
     }
-    void delmin() {
-       assert (size());
-       T last = heap_arr_.top();
+    void delmin () {
+       assert (size ());
+       T last = heap_array_.top ();
        
        int mini=2;
        int lasti=1;
 
-       while ( mini < size()) {
+       while (mini < size ()) {
            if (compare (elt (mini + 1), elt (mini)) <0)
                mini++;
            if (compare (last,elt (mini)) < 0)
@@ -95,12 +95,12 @@ public:
            mini *= 2;
        }
        elt (lasti) = last;
-       heap_arr_.pop();
-       OK();
+       heap_array_.pop ();
+       OK ();
     }
-    T get() { 
-       T t = front();
-       delmin();
+    T get () { 
+       T t = front ();
+       delmin ();
        return t;
     }
 };