* flower/include/std-vector.hh

[lilypond.git] / flower / include / std-vector.hh

diff --git a/flower/include/std-vector.hh b/flower/include/std-vector.hh
index db6cb9241e486d287eecf32786353a62fa5b8e52..7c957202621b63e7d002bce5f503bbd05ba9db3a 100644 (file)
--- a/flower/include/std-vector.hh
+++ b/flower/include/std-vector.hh
@@ -41,52 +41,23 @@ namespace std {
   {
   public:
     typedef typename __vector<T>::iterator iterator;
+    typedef typename __vector<T>::const_iterator const_iterator;
 
     vector<T> () : __vector<T> ()
     {
     }
 
-    vector<T> (iterator const b, iterator const e) : __vector<T> (b, e)
+    vector<T> (const_iterator b, const_iterator e) : __vector<T> (b, e)
     {
     }
 
-    vector<T> (vsize b, vsize e) : __vector<T> (iter (b), iter (e))
-    {
-    }
-
-    iterator iter (vsize n)
-    {
-      if (n == VPOS)
-       return this->end ();
-      return __vector<T>::begin () + n;
-    }
-
-    iterator const iter (vsize n) const
-    {
-      if (n == VPOS)
-       return this->end ();
-      return __vector<T>::begin () + n;
-    }
-
-    void
-    insert (T k, vsize i)
-    {
-      __vector<T>::insert (this->iter (i), k);
-    }
-
-    void
-    insert (vector<T> &v, vsize i)
-    {
-      __vector<T>::insert (iter (i), v.begin (), v.end ());
-    }
-
+    /* Flower-Array compatibility.  */
     void
     concat (vector<T> const &v)
     {
       __vector<T>::insert (this->end (), v.begin (), v.end ());
     }
 
-    /* Flower-Array compatibility.  */
     T const &
     boundary (int dir, vsize i) const
     {
@@ -107,53 +78,14 @@ namespace std {
        return this->at (i);
     }
 
-    T const &
-    elem (vsize i) const
-    {
-      return this->at (i);
-    }
-
-    T &
-    elem (vsize i)
-    {
-      return this->at (i);
-    }
-
-#if 1 // FIXME, silly, but keep for s/r
-    T const &
-    elem_ref (vsize i) const
-    {
-      return elem (i);
-    }
-
-    T &
-    elem_ref (vsize i)
-    {
-      return elem (i);
-    }
-#endif
-
-#if 0
-    T *
-    remove_array ()
-    {
-      // FIXME, no algorithm for this?
-      T *p = new T[this->size ()];
-      for (vsize i = 0; i < this->size (); i++)
-       p[i] = (*this)[i];
-      this->clear ();
-      return p;
-    }
-#else
     T *
     remove_array ()
     {
       T *p = &(*this)[0];
-      // forget array?
-      //this->resize (0);
+      /* FIXME: forget array? */
+      /* this->resize (0); */
       return p;
     }
-#endif
 
     void
     reverse ()
@@ -163,24 +95,6 @@ namespace std {
       ::std::reverse (this->begin (), this->end ());
     }
 
-    vector<T>
-    slice (vsize b, vsize e) const
-    {
-      return vector<T> (b, e);
-    }
-
-    void
-    sort (int vsize=VPOS, vsize b=VPOS, vsize e=VPOS)
-    {
-      ::std::sort (iter (b), iter(e));
-    }
-
-    void
-    sort (int (*compare) (T const &, T const &), int b=-1, int e=-1)
-    {
-      ::std::sort (iter (b), iter(e), compare);
-    }
-
     void swap (vsize i, vsize j)
     {
       T t ((*this)[i]);
@@ -210,7 +124,7 @@ namespace std {
                 vsize b=0, vsize e=VPOS)
   {
     //(void) compare;
-    vector<T>::iterator const i = find (v.iter (b), v.iter (e), key);
+    typename vector<T>::const_iterator i = find (v.iter (b), v.iter (e), key);
     if (i != v.end ())
       return i - v.begin ();
     return VPOS;
@@ -261,6 +175,48 @@ namespace std {
   }
 #endif
 
+
+#if 0
+  /* FIXME: the simple test works, but lily barfs.  */
+  template<typename T>
+  void
+  vector_sort (vector<T> &v, int (*compare) (T const &, T const &),
+              vsize lower=VPOS, vsize upper=VPOS)
+  {
+    typename vector<T>::iterator b = v.begin ();
+    typename vector<T>::iterator e = v.begin ();
+    if (lower == VPOS)
+      {
+       lower = 0;
+       upper = v.size ();
+      }
+    ::std::sort (b + lower, e + upper, compare);
+  }
+#else
+  // ugh, c&p
+template<typename T> void
+vector_sort (vector<T> &v, int (*compare) (T const &, T const &),
+            vsize lower=VPOS, vsize upper=VPOS)
+{
+  if (lower == VPOS)
+    {
+      lower = 0;
+      upper = v.size () - 1;
+    }
+  if (upper == VPOS || lower >= upper)
+    return;
+  v.swap (lower, (lower + upper) / 2);
+  vsize last = lower;
+  for (vsize i = lower +1; i <= upper; i++)
+    if (compare (v[i], v[lower]) < 0)
+      v.swap (++last, i);
+  v.swap (lower, last);
+  vector_sort (v, compare, lower, last - 1);
+  vector_sort (v, compare, last + 1, upper);
+}
+  
+#endif
+
 }
 
 
@@ -286,6 +242,18 @@ namespace std {
 
 #endif /* STD_VECTOR */
 
+template<typename T>
+int default_compare (T const &a, T const &b)
+{
+   if (a < b)
+     return -1;
+   else if (a > b)
+     return 1;
+   else
+     return 0;
+}
+ 
+
 #include "array.hh"
 
 #endif /* STD_VECTOR_HH */