From: Jan Nieuwenhuizen Date: Thu, 2 Feb 2006 09:15:46 +0000 (+0000) Subject: * flower/include/std-vector.hh X-Git-Tag: release/2.7.31~17 X-Git-Url: https://git.donarmstrong.com/?a=commitdiff_plain;h=586d833b4fb7a336524eb0929d693095a802fa26;p=lilypond.git * 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 8eeabac1d7..d25f34c346 100644 --- 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 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 const &src) diff --git a/flower/include/drul-array.hh b/flower/include/drul-array.hh index 34ea3c8bbe..09c8a22fa4 100644 --- a/flower/include/drul-array.hh +++ b/flower/include/drul-array.hh @@ -19,23 +19,23 @@ template 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 void scale_drul (Drul_array *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 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 01754b9716..6cc16eb696 100644 --- a/flower/include/interval.hh +++ b/flower/include/interval.hh @@ -20,29 +20,28 @@ template struct Interval_t : public Drul_array { - Drul_array::elem; - Drul_array::elem_ref; + Drul_array::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 void intersect (Interval_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 */ bool is_empty () const { - return elem (LEFT) > elem (RIGHT); + return at (LEFT) > at (RIGHT); } bool superset (Interval_t const &) const; Interval_t () @@ -90,16 +89,16 @@ struct Interval_t : public Drul_array Interval_t &operator += (T r) { - elem_ref (LEFT) += r; - elem_ref (RIGHT) += r; + at (LEFT) += r; + at (RIGHT) += r; return *this; } Interval_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 Real linear_combination (Real x) const { - Drul_array da (elem (LEFT), elem (RIGHT)); + Drul_array 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 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 const &a, Interval_t const &b) @@ -216,7 +215,7 @@ inline T Interval_t::center () const { assert (!is_empty ()); - return (elem (LEFT) + elem (RIGHT)) / T (2); + return (at (LEFT) + at (RIGHT)) / T (2); } typedef Interval_t Interval; diff --git a/flower/include/interval.tcc b/flower/include/interval.tcc index 396904d05d..a72837bd9f 100644 --- a/flower/include/interval.tcc +++ b/flower/include/interval.tcc @@ -22,13 +22,13 @@ template int _Interval__compare (const Interval_t &a, Interval_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 void Interval_t::set_empty () { - elem_ref (LEFT) = (T) infinity (); - elem_ref (RIGHT) = (T) -infinity (); + at (LEFT) = (T) infinity (); + at (RIGHT) = (T) -infinity (); } template void Interval_t::set_full () { - elem_ref (LEFT) = (T) -infinity (); - elem_ref (RIGHT) = (T) infinity (); + at (LEFT) = (T) -infinity (); + at (RIGHT) = (T) infinity (); } template T Interval_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 T Interval_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 void Interval_t::unite (Interval_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 void Interval_t::intersect (Interval_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 @@ -112,15 +112,15 @@ Interval_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 bool Interval_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; \ diff --git a/flower/include/parray.hh b/flower/include/parray.hh index b4d00af4f5..80145929e1 100644 --- 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::at (i); } - T *&elem_ref (int i) const + T const *at (int i) const { - return (T *&) Array::elem_ref (i); + return (T const *) Array::at (i); } /// access element T *&operator [] (int i) { - return (T *&) Array::elem_ref (i); + return (T *&) Array::at (i); } /// access element T *const operator [] (int i) const { - return (T *const) Array::elem (i); + return (T *const) Array::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 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::erase (Array::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::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 ca2e26ded3..7c95720262 100644 --- a/flower/include/std-vector.hh +++ b/flower/include/std-vector.hh @@ -51,13 +51,13 @@ namespace std { { } + /* Flower-Array compatibility. */ void concat (vector const &v) { __vector::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 d6db6f24ef..013887153d 100644 --- 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 9d5d5aa212..448871d574 100644 --- 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 e0bd749296..2a81321e0a 100644 --- 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 fba025349d..ee1d3e78a2 100644 --- a/lily/grob-array.cc +++ b/lily/grob-array.cc @@ -15,13 +15,13 @@ Item * Grob_array::item (vsize i) { - return dynamic_cast (grobs_.elem (i)); + return dynamic_cast (grobs_.at (i)); } Spanner * Grob_array::spanner (vsize i) { - return dynamic_cast (grobs_.elem (i)); + return dynamic_cast (grobs_.at (i)); } Grob_array::Grob_array () diff --git a/lily/include/grob-array.hh b/lily/include/grob-array.hh index 975301f723..99a0dcd404 100644 --- 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 31fc8d0b26..907c95985f 100644 --- 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 aa6a9cc40d..ead2e3a835 100644 --- 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 d049e1664a..56a0c37d28 100644 --- 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 *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 00498e724c..ee2d4e3281 100644 --- 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 18696b8eeb..6c2007ed5b 100644 --- a/lily/skyline.cc +++ b/lily/skyline.cc @@ -56,26 +56,26 @@ insert_extent_into_skyline (std::vector *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 *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 8b54857b1d..bcac1ea5f7 100644 --- 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 *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 *cols, Set distance constraints for loose columns */ Drul_array 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 dists (0, 0); @@ -212,8 +212,8 @@ Spacing_spanner::prune_loose_columns (Grob *me, Link_array *cols, Rod r; r.distance_ = dists[LEFT] + dists[RIGHT]; - r.item_drul_[LEFT] = dynamic_cast (cols->elem (i - 1)); - r.item_drul_[RIGHT] = dynamic_cast (cols->elem (i + 1)); + r.item_drul_[LEFT] = dynamic_cast (cols->at (i - 1)); + r.item_drul_[RIGHT] = dynamic_cast (cols->at (i + 1)); r.add_to_cols (); } diff --git a/lily/system.cc b/lily/system.cc index 8bd370579f..423fbac24f 100644 --- 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 b256039498..4f3449caa2 100644 --- a/lily/tie-formatting-problem.cc +++ b/lily/tie-formatting-problem.cc @@ -104,7 +104,7 @@ Tie_formatting_problem::set_chord_outline (Link_array 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 a11a33e822..a0dd3d0c2c 100644 --- a/lily/translator.cc +++ b/lily/translator.cc @@ -178,8 +178,8 @@ generic_get_acknowledger (SCM sym, std::vector 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; }