* flower/include/std-vector.hh

* flower/include/parray.hh
* flower/include/array.hh (elem, elem_ref): Globally replace by
at ().

diff --git a/flower/include/array.hh b/flower/include/array.hh
index 8eeabac1d74d3d6ac257b7bad599e1469c40bc65..d25f34c346e995460ac31f59ecc8c99dc005c9be 100644 (file)
--- a/flower/include/array.hh
+++ b/flower/include/array.hh
@@ -17,6 +17,12 @@ using namespace std;
 #define INLINE inline
 #endif
 
+#if !STD_VECTOR
+#define index_assert(i) (assert (i >= 0 && i < size_));
+#else
+#define index_assert(i) (assert (i != VPOS && i < size_));
+#endif
+
 namespace std {
 /// copy a bare (C-)array from #src# to #dest# sized  #count#
 template<class T> void arrcpy (T *dest, T const *src, int count);
@@ -157,33 +163,48 @@ public:
     size_ = 0;
   }
 
-  /* std::vector uses unchecked variant for [] */
+  T &
+  at (vsize i)
+  {
+    return (*this)[i];
+  }
+
+  T const &
+  at (vsize i) const
+  {
+    return (*this)[i];
+  }
+
   T &operator [] (vsize i)
   {
-    return elem_ref (i);
+    return array_[i];
   }
 
-  /* std::vector uses unchecked variant for [] */
   T const &operator [] (vsize i) const
   {
-    return elem_ref (i);
+    return array_[i];
   }
 
   iterator
   erase (iterator p)
   {
     vsize i = p - data ();
-#if !STD_VECTOR
-    assert (i >= 0 && i < size_);
-#else
-    assert (i < size_);
-#endif
+    index_assert (i);
     arrcpy (array_ + i, array_ + i + 1, size_ - i - 1);
     size_--;
     return p;
   }
 
+  /// add to the end of array
+  void push_back (T x)
+  {
+    if (size_ == max_)
+      remax (2 * max_ + 1);
 
+    // T::operator= (T &) is called here. Safe to use with automatic
+    // vars
+    array_[size_++] = x;
+  }
 
 
   /* Flower intererface */
@@ -241,43 +262,6 @@ public:
 
   T *remove_array ();
 
-  /// access element
-  T &elem_ref (vsize i) const
-  {
-#if !STD_VECTOR
-    assert (i >= 0 && i < size_);
-#else
-    assert (i < size_);
-#endif
-    return ((T *)array_)[i];
-  }
-  /// access element
-  T elem (vsize i) const
-  {
-    return elem_ref (i);
-  }
-
-  /// add to the end of array
-  void push_back (T x)
-  {
-    if (size_ == max_)
-      remax (2 * max_ + 1);
-
-    // T::operator= (T &) is called here. Safe to use with automatic
-    // vars
-    array_[size_++] = x;
-  }
-#if 0
-  /// remove and return last entry 
-  T pop ()
-  {
-    assert (!empty ());
-    T l = top (0);
-    resize (size () - 1);
-    return l;
-  }
-#endif
-
   /// access last entry
   T &top (vsize j)
   {
@@ -295,7 +279,7 @@ public:
     if (dir == 1)
       return top (idx);
     else
-      return elem_ref (idx);
+      return at (idx);
   }
   T boundary (int dir, vsize idx) const
   {
@@ -303,7 +287,7 @@ public:
     if (dir == 1)
       return top (idx);
     else
-      return elem (idx);
+      return at (idx);
   }
   void swap (vsize i, vsize j)
   {
@@ -316,7 +300,7 @@ public:
 
   void unordered_del (vsize i)
   {
-    elem_ref (i) = back ();
+    at (i) = back ();
     resize (size () -1);
   }
   void concat (Array<T> const &src)

diff --git a/flower/include/drul-array.hh b/flower/include/drul-array.hh
index 34ea3c8bbef769b406c7ec06f4185d10bc5248d6..09c8a22fa4ca461205689d0c79a429f8a2e94563 100644 (file)
--- a/flower/include/drul-array.hh
+++ b/flower/include/drul-array.hh
@@ -19,23 +19,23 @@ template<class T>
 struct Drul_array
 {
   T array_[2];
-  T &elem_ref (Direction d)
+  T &at (Direction d)
   {
     assert (d == 1 || d == -1);
     return array_[ (d + 1) / 2];
   }
-  T elem (Direction d) const
+  T const &at (Direction d) const
   {
     assert (d == 1 || d == -1);
     return array_[ (d + 1) / 2];
   }
   T &operator [] (Direction d)
   {
-    return elem_ref (d);
+    return at (d);
   }
-  T operator [] (Direction d) const
+  T const& operator [] (Direction d) const
   {
-    return elem (d);
+    return at (d);
   }
   Drul_array ()
   {
@@ -51,15 +51,15 @@ template<class T>
 void
 scale_drul (Drul_array<T> *dr, T x)
 {
-  dr->elem_ref (LEFT) *= x;
-  dr->elem_ref (RIGHT) *= x;
+  dr->at (LEFT) *= x;
+  dr->at (RIGHT) *= x;
 }
 
 inline Real
 linear_combination (Drul_array<Real> const &d, Real x)
 {
-  return ((1.0 - x) * Real (d.elem (LEFT))
-         + (x + 1.0) * Real (d.elem (RIGHT))) * 0.5;
+  return ((1.0 - x) * Real (d.at (LEFT))
+         + (x + 1.0) * Real (d.at (RIGHT))) * 0.5;
 }
 
 #endif /* DRUL_ARRAY_HH */

diff --git a/flower/include/interval.hh b/flower/include/interval.hh
index 01754b9716917c06b476e6340be38651e7b7fe17..6cc16eb6966c9a5815c671aacc011c8cf162697d 100644 (file)
--- a/flower/include/interval.hh
+++ b/flower/include/interval.hh
@@ -20,29 +20,28 @@
 template<class T>
 struct Interval_t : public Drul_array<T>
 {
-  Drul_array<T>::elem;
-  Drul_array<T>::elem_ref;
+  Drul_array<T>::at;
 
   static T infinity ();
   static std::string T_to_string (T arg);
   T center () const;
   void translate (T t)
   {
-    elem_ref (LEFT) += t;
-    elem_ref (RIGHT) += t;
+    at (LEFT) += t;
+    at (RIGHT) += t;
   }
   void widen (T t)
   {
-    elem_ref (LEFT) -= t;
-    elem_ref (RIGHT) += t;
+    at (LEFT) -= t;
+    at (RIGHT) += t;
   }
 
   T distance (T t) const
   {
-    if (t > elem (RIGHT))
-      return T (t - elem (RIGHT));
-    else if (t < elem (LEFT))
-      return T (elem (LEFT) - t);
+    if (t > at (RIGHT))
+      return T (t - at (RIGHT));
+    else if (t < at (LEFT))
+      return T (at (LEFT) - t);
     else
       return T (0);
   }
@@ -54,8 +53,8 @@ struct Interval_t : public Drul_array<T>
   void intersect (Interval_t<T> h);
   void add_point (T p)
   {
-    elem_ref (LEFT) = min (elem (LEFT), p);
-    elem_ref (RIGHT) = max (elem (RIGHT), p);
+    at (LEFT) = min (at (LEFT), p);
+    at (RIGHT) = max (at (RIGHT), p);
   }
   T length () const;
   T delta () const;
@@ -67,7 +66,7 @@ struct Interval_t : public Drul_array<T>
   */
   bool is_empty () const
   {
-    return elem (LEFT) > elem (RIGHT);
+    return at (LEFT) > at (RIGHT);
   }
   bool superset (Interval_t<T> const &) const;
   Interval_t ()
@@ -90,16 +89,16 @@ struct Interval_t : public Drul_array<T>
 
   Interval_t<T> &operator += (T r)
   {
-    elem_ref (LEFT) += r;
-    elem_ref (RIGHT) += r;
+    at (LEFT) += r;
+    at (RIGHT) += r;
     return *this;
   }
   Interval_t<T> &operator *= (T r)
   {
     if (!is_empty ())
       {
-       elem_ref (LEFT) *= r;
-       elem_ref (RIGHT) *= r;
+       at (LEFT) *= r;
+       at (RIGHT) *= r;
        if (r < T (0))
          swap ();
       }
@@ -108,7 +107,7 @@ struct Interval_t : public Drul_array<T>
 
   Real linear_combination (Real x) const
   {
-    Drul_array<Real> da (elem (LEFT), elem (RIGHT));
+    Drul_array<Real> da (at (LEFT), at (RIGHT));
     return ::linear_combination (da, x);
   }
   std::string to_string () const;
@@ -116,17 +115,17 @@ struct Interval_t : public Drul_array<T>
   bool contains (T r) const;
   void negate ()
   {
-    T r = -elem (LEFT);
-    T l = -elem (RIGHT);
-    elem_ref (LEFT) = l;
-    elem_ref (RIGHT) = r;
+    T r = -at (LEFT);
+    T l = -at (RIGHT);
+    at (LEFT) = l;
+    at (RIGHT) = r;
   }
 
   void swap ()
   {
-    T t = elem (LEFT);
-    elem_ref (LEFT) = elem (RIGHT);
-    elem_ref (RIGHT) = t;
+    T t = at (LEFT);
+    at (LEFT) = at (RIGHT);
+    at (RIGHT) = t;
   }
 
   static int left_comparison (Interval_t<T> const &a, Interval_t<T> const &b)
@@ -216,7 +215,7 @@ inline T
 Interval_t<T>::center () const
 {
   assert (!is_empty ());
-  return (elem (LEFT) + elem (RIGHT)) / T (2);
+  return (at (LEFT) + at (RIGHT)) / T (2);
 }
 
 typedef Interval_t<Real> Interval;

diff --git a/flower/include/interval.tcc b/flower/include/interval.tcc
index 396904d05d908d9676e14f523285a9e5a419e986..a72837bd9facee3c0f3496e5c7ec46ff94fc8263 100644 (file)
--- a/flower/include/interval.tcc
+++ b/flower/include/interval.tcc
@@ -22,13 +22,13 @@ template<class T>
 int
 _Interval__compare (const Interval_t<T> &a, Interval_t<T> const &b)
 {
-  if (a.elem (LEFT) == b.elem (LEFT) && a.elem (RIGHT) == b.elem (RIGHT))
+  if (a.at (LEFT) == b.at (LEFT) && a.at (RIGHT) == b.at (RIGHT))
     return 0;
 
-  if (a.elem (LEFT) <= b.elem (LEFT) && a.elem (RIGHT) >= b.elem (RIGHT))
+  if (a.at (LEFT) <= b.at (LEFT) && a.at (RIGHT) >= b.at (RIGHT))
     return 1;
 
-  if (a.elem (LEFT) >= b.elem (LEFT) && a.elem (RIGHT) <= b.elem (RIGHT))
+  if (a.at (LEFT) >= b.at (LEFT) && a.at (RIGHT) <= b.at (RIGHT))
     return -1;
 
   return -2;
@@ -58,33 +58,33 @@ template<class T>
 void
 Interval_t<T>::set_empty ()
 {
-  elem_ref (LEFT) = (T) infinity ();
-  elem_ref (RIGHT) = (T) -infinity ();
+  at (LEFT) = (T) infinity ();
+  at (RIGHT) = (T) -infinity ();
 }
 
 template<class T>
 void
 Interval_t<T>::set_full ()
 {
-  elem_ref (LEFT) = (T) -infinity ();
-  elem_ref (RIGHT) = (T) infinity ();
+  at (LEFT) = (T) -infinity ();
+  at (RIGHT) = (T) infinity ();
 }
 
 template<class T>
 T
 Interval_t<T>::length () const
 {
-  if (elem (RIGHT) <= elem (LEFT))
+  if (at (RIGHT) <= at (LEFT))
     return 0;
   else
-    return elem (RIGHT) - elem (LEFT);
+    return at (RIGHT) - at (LEFT);
 }
 
 template<class T>
 T
 Interval_t<T>::delta () const
 {
-  return elem (RIGHT) - elem (LEFT);
+  return at (RIGHT) - at (LEFT);
 }
 
 /* smallest Interval which includes *this and #h#  */
@@ -92,16 +92,16 @@ template<class T>
 void
 Interval_t<T>::unite (Interval_t<T> h)
 {
-  elem_ref (LEFT) = min (h.elem (LEFT), elem (LEFT));
-  elem_ref (RIGHT) = max (h.elem (RIGHT), elem (RIGHT));
+  at (LEFT) = min (h.at (LEFT), at (LEFT));
+  at (RIGHT) = max (h.at (RIGHT), at (RIGHT));
 }
 
 template<class T>
 void
 Interval_t<T>::intersect (Interval_t<T> h)
 {
-  elem_ref (LEFT) = max (h.elem (LEFT), elem (LEFT));
-  elem_ref (RIGHT) = min (h.elem (RIGHT), elem (RIGHT));
+  at (LEFT) = max (h.at (LEFT), at (LEFT));
+  at (RIGHT) = min (h.at (RIGHT), at (RIGHT));
 }
 
 template<class T>
@@ -112,15 +112,15 @@ Interval_t<T>::to_string () const
     return "[empty]";
   std::string s ("[");
 
-  return (s + T_to_string (elem (LEFT)) + std::string (",")
-         + T_to_string (elem (RIGHT)) + std::string ("]"));
+  return (s + T_to_string (at (LEFT)) + std::string (",")
+         + T_to_string (at (RIGHT)) + std::string ("]"));
 }
 
 template<class T>
 bool
 Interval_t<T>::contains (T r) const
 {
-  return r >= elem (LEFT) && r <= elem (RIGHT);
+  return r >= at (LEFT) && r <= at (RIGHT);
 }
 
 #define INTERVAL__INSTANTIATE(T) struct Interval_t<T>;                 \

diff --git a/flower/include/parray.hh b/flower/include/parray.hh
index b4d00af4f5b0b87fc735e122d5b0b653fe00a38b..80145929e141f04d996b837a73c5d3e5cdc8e9a6 100644 (file)
--- a/flower/include/parray.hh
+++ b/flower/include/parray.hh
@@ -75,25 +75,24 @@ public:
   {
   }
 
-  /// access element
-  T *elem (int i) const
+  T *at (int i)
   {
-    return elem_ref (i);
+    return (T *) Array<void *>::at (i);
   }
-  T *&elem_ref (int i) const
+  T const *at (int i) const
   {
-    return (T *&) Array<void *>::elem_ref (i);
+    return (T const *) Array<void *>::at (i);
   }
 
   /// access element
   T *&operator [] (int i)
   {
-    return (T *&) Array<void *>::elem_ref (i);
+    return (T *&) Array<void *>::at (i);
   }
   /// access element
   T *const operator [] (int i) const
   {
-    return (T *const) Array<void *>::elem (i);
+    return (T *const) Array<void *>::at (i);
   }
   T *pop ()
   {
@@ -125,7 +124,7 @@ public:
     int i;
     while ((i = find_index (old)) >= 0)
       if (new_p)
-       elem_ref (i) = new_p;
+       at (i) = new_p;
       else
        erase (begin () + i);
   }
@@ -134,7 +133,7 @@ public:
     int i;
     while ((i = find_index (old)) >= 0)
       if (new_p)
-       elem_ref (i) = new_p;
+       at (i) = new_p;
       else
        unordered_del (i);
   }
@@ -151,8 +150,8 @@ public:
   {
     Link_array<T> ls;
     for (vsize i = 0; i < size (); i++)
-      if (!i || elem (i - 1) != elem (i))
-       ls.push_back (elem (i));
+      if (!i || at (i - 1) != at (i))
+       ls.push_back (at (i));
     *this = ls;
   }
 
@@ -162,7 +161,7 @@ public:
     if (d == 1)
       return top (i);
     else
-      return elem_ref (i);
+      return at (i);
   }
   T *boundary (int d, int i)const
   {
@@ -170,7 +169,7 @@ public:
     if (d == 1)
       return top (i);
     else
-      return elem_ref (i);
+      return at (i);
   }
 
   T ** accesses () const
@@ -182,7 +181,7 @@ public:
   */
   T *get (vsize i)
   {
-    T *t = elem (i);
+    T *t = at (i);
     Array<void*>::erase (Array<void*>::begin () + i);
     return t;
   }
@@ -198,15 +197,15 @@ public:
   int find_index (T const *t) const
   {
     for (vsize i = 0; i < size (); i++)
-      if (elem (i) == t)
+      if (at (i) == t)
        return i;
     return -1;
   }
-  T *find (T const *t) const
+  T const *find (T const *t) const
   {
     int i = find_index (t);
     if (i >= 0)
-      return elem (i);
+      return at (i);
     else
       return 0;
   }
@@ -235,7 +234,7 @@ Link_array<T>::sort (int (*compare) (T *const &, T *const &), int lower, int upp
   swap (lower, (lower + upper) / 2);
   int last = lower;
   for (int i = lower +1; i <= upper; i++)
-    if (compare (elem (i), elem (lower)) < 0)
+    if (compare (at (i), at (lower)) < 0)
       swap (++last, i);
   swap (lower, last);
   sort (compare, lower, last - 1);

diff --git a/flower/include/std-vector.hh b/flower/include/std-vector.hh
index ca2e26ded32e800abf6adadfbb3afadfe133f0f2..7c957202621b63e7d002bce5f503bbd05ba9db3a 100644 (file)
--- a/flower/include/std-vector.hh
+++ b/flower/include/std-vector.hh
@@ -51,13 +51,13 @@ namespace std {
     {
     }
 
+    /* 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
     {
@@ -78,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 ()

diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc
index d6db6f24ef4e659ade9acb859b324cc7de8931fe..013887153dfc25e0d211e5b524e6e2f77fbba05b 100644 (file)
--- a/lily/accidental-placement.cc
+++ b/lily/accidental-placement.cc
@@ -95,7 +95,7 @@ Accidental_placement::get_relevant_accidental_extent (Grob *me,
 
   Interval extent;
   for (vsize i = 0; i < which->size (); i++)
-    extent.unite (which->elem (i)->extent (item_col, X_AXIS));
+    extent.unite (which->at (i)->extent (item_col, X_AXIS));
 
   if (!extent.is_empty ())
     {

diff --git a/lily/beam.cc b/lily/beam.cc
index 9d5d5aa212560f6c133cd4b8e03d40f282312ed0..448871d574ed47d9909f45a0d0a4e19cacdbdd11 100644 (file)
--- a/lily/beam.cc
+++ b/lily/beam.cc
@@ -1175,11 +1175,11 @@ Beam::set_beaming (Grob *me, Beaming_info_list const *beaming)
          if (beaming_prop == SCM_EOL
              || index_get_cell (beaming_prop, d) == SCM_EOL)
            {
-             int b = beaming->infos_.elem (i).beams_i_drul_[d];
+             int b = beaming->infos_.at (i).beams_i_drul_[d];
              if (i > 0
                  && i < stems.size () -1
                  && Stem::is_invisible (stem))
-               b = min (b, beaming->infos_.elem (i).beams_i_drul_[-d]);
+               b = min (b, beaming->infos_.at (i).beams_i_drul_[-d]);
 
              Stem::set_beaming (stem, b, d);
            }

diff --git a/lily/global-ctor.cc b/lily/global-ctor.cc
index e0bd7492966b4049c4eb0c1527a38769bd4ea474..2a81321e0a731a861398307494e26f7b329d8806 100644 (file)
--- a/lily/global-ctor.cc
+++ b/lily/global-ctor.cc
@@ -24,5 +24,5 @@ void
 call_constructors ()
 {
   for (vsize i = 0; i < ctor_global_statics_->size (); i++)
-    (ctor_global_statics_->elem (i)) ();
+    (ctor_global_statics_->at (i)) ();
 }

diff --git a/lily/grob-array.cc b/lily/grob-array.cc
index fba025349d41dba02af11d97485bf9aa83c556cd..ee1d3e78a2009dbaf620cb793562791427a72a07 100644 (file)
--- a/lily/grob-array.cc
+++ b/lily/grob-array.cc
@@ -15,13 +15,13 @@
 Item *
 Grob_array::item (vsize i)
 {
-  return dynamic_cast<Item *> (grobs_.elem (i));
+  return dynamic_cast<Item *> (grobs_.at (i));
 }
 
 Spanner *
 Grob_array::spanner (vsize i)
 {
-  return dynamic_cast<Spanner *> (grobs_.elem (i));
+  return dynamic_cast<Spanner *> (grobs_.at (i));
 }
 
 Grob_array::Grob_array ()

diff --git a/lily/include/grob-array.hh b/lily/include/grob-array.hh
index 975301f7232b5f3e4f11d87be7727b4f1e4545e0..99a0dcd4048dc07262077795f9f8d3e1bbf05539 100644 (file)
--- a/lily/include/grob-array.hh
+++ b/lily/include/grob-array.hh
@@ -26,7 +26,7 @@ public:
   void set_ordered (bool b) { ordered_ = b; }
   Item *item (vsize i);
   Spanner *spanner (vsize i);
-  Grob *grob (vsize i) { return grobs_.elem (i); }
+  Grob *grob (vsize i) { return grobs_.at (i); }
   vsize size () const { return grobs_.size (); }
   bool empty () const;
   void clear ();

diff --git a/lily/ledger-line-spanner.cc b/lily/ledger-line-spanner.cc
index 31fc8d0b26b814a5b3cdc9eda6c8d0d55175abab..907c95985f7f015c331ada15718d21f5fb771c4c 100644 (file)
--- a/lily/ledger-line-spanner.cc
+++ b/lily/ledger-line-spanner.cc
@@ -290,7 +290,7 @@ Ledger_line_spanner::print (SCM smob)
                       && !staff_extent.contains (i->second[d].position_
                                                  - sign (i->second[d].position_)));
                  Real limit = (center + (both ? which * gap / 2 : 0));
-                 lr.ledger_extent_.elem_ref (-which)
+                 lr.ledger_extent_.at (-which)
                    = which * max (which * lr.ledger_extent_[-which], which * limit);
                }
              while (flip (&which) != LEFT);

diff --git a/lily/lily-guile.cc b/lily/lily-guile.cc
index aa6a9cc40db4f84971ab34f27af43a2b0f595805..ead2e3a8359a1804bf4f5b2d578e1c0a94307cc0 100644 (file)
--- a/lily/lily-guile.cc
+++ b/lily/lily-guile.cc
@@ -193,7 +193,7 @@ void
 ly_init_ly_module (void *)
 {
   for (vsize i = scm_init_funcs_->size (); i--;)
-    (scm_init_funcs_->elem (i)) ();
+    (scm_init_funcs_->at (i)) ();
 
   if (be_verbose_global)
     {

diff --git a/lily/new-fingering-engraver.cc b/lily/new-fingering-engraver.cc
index d049e1664ab092f307075da6fd0eb1b0224aee19..56a0c37d28afa9b58c83afcec9d831ed3c393794 100644 (file)
--- a/lily/new-fingering-engraver.cc
+++ b/lily/new-fingering-engraver.cc
@@ -190,8 +190,8 @@ New_fingering_engraver::position_scripts (SCM orientations,
                                          std::vector<Finger_tuple> *scripts)
 {
   for (vsize i = 0; i < scripts->size (); i++)
-    if (stem_ && to_boolean (scripts->elem (i).script_->get_property ("add-stem-support")))
-      Side_position_interface::add_support (scripts->elem (i).script_, stem_);
+    if (stem_ && to_boolean (scripts->at (i).script_->get_property ("add-stem-support")))
+      Side_position_interface::add_support (scripts->at (i).script_, stem_);
 
   /*
     This is not extremely elegant, but we have to do a little

diff --git a/lily/pitch-interval.cc b/lily/pitch-interval.cc
index 00498e724c3a914f6b3c482af7539d37cf914d03..ee2d4e32810fc51ee8b1d96ca0c216cf3d6b1f62 100644 (file)
--- a/lily/pitch-interval.cc
+++ b/lily/pitch-interval.cc
@@ -12,27 +12,27 @@
 
 Pitch_interval::Pitch_interval (Pitch p1, Pitch p2)
 {
-  elem_ref (LEFT) = p1;
-  elem_ref (RIGHT) = p2;
+  at (LEFT) = p1;
+  at (RIGHT) = p2;
 }
 
 Pitch_interval::Pitch_interval ()
 {
-  elem_ref (LEFT) = Pitch (100, 0, 0);
-  elem_ref (RIGHT) = Pitch (-100, 0, 0);
+  at (LEFT) = Pitch (100, 0, 0);
+  at (RIGHT) = Pitch (-100, 0, 0);
 }
 
 bool
 Pitch_interval::is_empty () const
 {
-  return elem (LEFT) > elem (RIGHT);
+  return at (LEFT) > at (RIGHT);
 }
 
 void
 Pitch_interval::add_point (Pitch p)
 {
-  if (elem_ref (LEFT) > p)
-    elem_ref (LEFT) = p;
-  if (elem_ref (RIGHT) < p)
-    elem_ref (RIGHT) = p;
+  if (at (LEFT) > p)
+    at (LEFT) = p;
+  if (at (RIGHT) < p)
+    at (RIGHT) = p;
 }

diff --git a/lily/skyline.cc b/lily/skyline.cc
index 18696b8eebddca0f3e4b38595b2791a7a70249c5..6c2007ed5babf021f6b49a8d8413dd4ee72c1a09 100644 (file)
--- a/lily/skyline.cc
+++ b/lily/skyline.cc
@@ -56,26 +56,26 @@ insert_extent_into_skyline (std::vector<Skyline_entry> *line, Box b, Axis line_a
   */
   for (vsize i = line->size (); i--;)
     {
-      Interval w = line->elem (i).width_;
+      Interval w = line->at (i).width_;
       w.intersect (extent);
 
       if (extent[LEFT] >= w[RIGHT])
        break;
 
-      Real my_height = line->elem (i).height_;
+      Real my_height = line->at (i).height_;
 
       if (!w.is_empty ()
          && w.length () > EPS
          && d * (my_height - stick_out) < 0)
        {
-         Interval e1 (line->elem (i).width_[LEFT], extent[LEFT]);
-         Interval e3 (extent[RIGHT], line->elem (i).width_[RIGHT]);
+         Interval e1 (line->at (i).width_[LEFT], extent[LEFT]);
+         Interval e3 (extent[RIGHT], line->at (i).width_[RIGHT]);
 
          if (!e3.is_empty () && e3.length () > EPS)
            line->insert (line->begin () + i + 1, Skyline_entry (e3, my_height));
 
-         line->elem_ref (i).height_ = stick_out;
-         line->elem_ref (i).width_ = w;
+         line->at (i).height_ = stick_out;
+         line->at (i).width_ = w;
          if (!e1.is_empty () && e1.length () > EPS)
            line->insert (line->begin () + i, Skyline_entry (e1, my_height));
        }
@@ -179,7 +179,7 @@ void
 heighten_skyline (std::vector<Skyline_entry> *buildings, Real ground)
 {
   for (vsize i = 0; i < buildings->size (); i++)
-    buildings->elem_ref (i).height_ += ground;
+    buildings->at (i).height_ += ground;
 }
 
 Real

diff --git a/lily/spacing-determine-loose-columns.cc b/lily/spacing-determine-loose-columns.cc
index 8b54857b1dedceb7b254277d787e388b83b2bffe..bcac1ea5f7ae3847e561569a46cbe554d90485cc 100644 (file)
--- a/lily/spacing-determine-loose-columns.cc
+++ b/lily/spacing-determine-loose-columns.cc
@@ -133,10 +133,10 @@ Spacing_spanner::prune_loose_columns (Grob *me, Link_array<Grob> *cols,
 
   for (vsize i = 0; i < cols->size (); i++)
     {
-      Grob *c = cols->elem (i);
+      Grob *c = cols->at (i);
 
       bool loose = (i > 0 && i < cols->size () - 1)
-       && is_loose_column (cols->elem (i - 1), c, cols->elem (i + 1), options);
+       && is_loose_column (cols->at (i - 1), c, cols->at (i + 1), options);
 
       if (loose)
        {
@@ -159,8 +159,8 @@ Spacing_spanner::prune_loose_columns (Grob *me, Link_array<Grob> *cols,
            Set distance constraints for loose columns
          */
          Drul_array<Grob *> next_door;
-         next_door[LEFT] = cols->elem (i - 1);
-         next_door[RIGHT] = cols->elem (i + 1);
+         next_door[LEFT] = cols->at (i - 1);
+         next_door[RIGHT] = cols->at (i + 1);
          Direction d = LEFT;
          Drul_array<Real> dists (0, 0);
 
@@ -212,8 +212,8 @@ Spacing_spanner::prune_loose_columns (Grob *me, Link_array<Grob> *cols,
 
          Rod r;
          r.distance_ = dists[LEFT] + dists[RIGHT];
-         r.item_drul_[LEFT] = dynamic_cast<Item *> (cols->elem (i - 1));
-         r.item_drul_[RIGHT] = dynamic_cast<Item *> (cols->elem (i + 1));
+         r.item_drul_[LEFT] = dynamic_cast<Item *> (cols->at (i - 1));
+         r.item_drul_[RIGHT] = dynamic_cast<Item *> (cols->at (i + 1));
 
          r.add_to_cols ();
        }

diff --git a/lily/system.cc b/lily/system.cc
index 8bd370579ff7be84cab5b631b3be687eb5642fe4..423fbac24f6f4a167e9816819aa2d14c05358df0 100644 (file)
--- a/lily/system.cc
+++ b/lily/system.cc
@@ -90,7 +90,7 @@ System::derived_mark () const
 {
   if (!all_elements_->empty ())
     {
-      Grob **ptr = &all_elements_->array_reference ().elem_ref (0);
+      Grob **ptr = &all_elements_->array_reference ()[0];
       Grob **end = ptr + all_elements_->size ();
       while (ptr < end)
        {

diff --git a/lily/tie-formatting-problem.cc b/lily/tie-formatting-problem.cc
index b2560394988b4a226da78743c06cb446a53cab18..4f3449caa27fcb343cec748e5a2da6646e5cf6ac 100644 (file)
--- a/lily/tie-formatting-problem.cc
+++ b/lily/tie-formatting-problem.cc
@@ -104,7 +104,7 @@ Tie_formatting_problem::set_chord_outline (Link_array<Item> bounds,
   if (bounds[0]->break_status_dir ())
     {
       Real x = robust_relative_extent (bounds[0],  x_refpoint_, X_AXIS)[-d];
-      chord_outlines_[d].elem_ref (0).height_ = x; 
+      chord_outlines_[d].at (0).height_ = x; 
     }
          
   for (vsize i = 0; i < boxes.size (); i++)
@@ -694,8 +694,8 @@ Tie_formatting_problem::set_ties_config_standard_directions (Ties_configuration
   if (tie_configs->empty ())
     return ;
   
-  if (!tie_configs->elem (0).dir_)
-    tie_configs->elem_ref (0).dir_ = DOWN;
+  if (!tie_configs->at (0).dir_)
+    tie_configs->at (0).dir_ = DOWN;
   if (!tie_configs->back ().dir_)
     tie_configs->back ().dir_ = UP;
 
@@ -704,21 +704,21 @@ Tie_formatting_problem::set_ties_config_standard_directions (Ties_configuration
    */
   for (vsize i = 1; i < tie_configs->size (); i++)
     {
-      Real diff = (tie_configs->elem (i-1).position_
-                  - tie_configs->elem (i).position_);
+      Real diff = (tie_configs->at (i-1).position_
+                  - tie_configs->at (i).position_);
 
       if (fabs (diff) <= 1)
        {
-         if (!tie_configs->elem (i-1).dir_)
-           tie_configs->elem_ref (i-1).dir_ = DOWN;
-         if (!tie_configs->elem (i).dir_)
-           tie_configs->elem_ref (i).dir_ = UP;
+         if (!tie_configs->at (i-1).dir_)
+           tie_configs->at (i-1).dir_ = DOWN;
+         if (!tie_configs->at (i).dir_)
+           tie_configs->at (i).dir_ = UP;
        }
     }
 
   for (vsize i = 1; i < tie_configs->size() - 1; i++)
     {
-      Tie_configuration &conf = tie_configs->elem_ref (i);
+      Tie_configuration &conf = tie_configs->at (i);
       if (conf.dir_)
        continue;
 

diff --git a/lily/translator.cc b/lily/translator.cc
index a11a33e82266c886cae09943a1b918d5b9d50017..a0dd3d0c2c0ce82c63526b7fc3e320e2f51fd172 100644 (file)
--- a/lily/translator.cc
+++ b/lily/translator.cc
@@ -178,8 +178,8 @@ generic_get_acknowledger (SCM sym, std::vector<Acknowledge_information> const *a
 {
   for (vsize i = 0; i < ack_array->size (); i++)
     {
-      if (ack_array->elem (i).symbol_ == sym)
-       return ack_array->elem (i).function_;
+      if (ack_array->at (i).symbol_ == sym)
+       return ack_array->at (i).function_;
     }
   return 0;
 }