Issue 4550: Avoid "using namespace std;" in included files (Take 2)

lily/axis-group-interface.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 2000--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
@@ skipping 22 matching lines @@
 #include "pointer-group-interface.hh"
 #include "separation-item.hh"
 #include "skyline-pair.hh"
 #include "staff-grouper-interface.hh"
 #include "stem.hh"
 #include "stencil.hh"
 #include "system.hh"
 #include "warn.hh"
 #include "unpure-pure-container.hh"
 
+using std::multimap;
+using std::pair;
+using std::string;
+using std::vector;
+
 static bool
 pure_staff_priority_less (Grob *const &g1, Grob *const &g2);
 
 Real Axis_group_interface::default_outside_staff_padding_ = 0.46;
 
 Real
 Axis_group_interface::get_default_outside_staff_padding ()
 {
   return default_outside_staff_padding_;
 }
@@ skipping 208 matching lines @@
         {
           begin_line_staff_heights = begin_line_heights;
           mid_line_staff_heights = mid_line_heights;
         }
 
       // TODO: consider a pure version of get_grob_direction?
       Direction d = to_dir (g->get_property_data ("direction"));
       d = (d == CENTER) ? UP : d;
 
       Interval_t<int> rank_span = g->spanned_rank_interval ();
-      vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], less<vsize> ());
+      vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], std::less<vsize> ());
       if (first_break > 0 && ranks[first_break] >= (vsize)rank_span[LEFT])
         first_break--;
 
       for (vsize j = first_break; j + 1 < ranks.size () && (int)ranks[j] <= rank_span[RIGHT]; ++j)
         {
           int start = ranks[j];
           int end = ranks[j + 1];
 
           // Take grobs that are visible with respect to a slightly longer line.
           // Otherwise, we will never include grobs at breakpoints which aren't
@@ skipping 33 matching lines @@
       scm_vector_set_x (mid_scm, scm_from_int (i), ly_interval2scm (mid_line_heights[i]));
     }
 
   return scm_cons (begin_scm, mid_scm);
 }
 
 Interval
 Axis_group_interface::relative_pure_height (Grob *me, int start, int end)
 {
   /* It saves a _lot_ of time if we assume a VerticalAxisGroup is additive
-     (ie. height (i, k) = max (height (i, j) height (j, k)) for all i <= j <= k).
+     (ie. height (i, k) = std::max (height (i, j) height (j, k)) for all i <= j <= k).
      Unfortunately, it isn't always true, particularly if there is a
      VerticalAlignment somewhere in the descendants.
 
      Usually, the only VerticalAlignment comes from Score. This makes it
      reasonably safe to assume that if our parent is a VerticalAlignment,
      we can assume additivity and cache things nicely. */
   Grob *p = me->get_parent (Y_AXIS);
   if (has_interface<Align_interface> (p))
     return Axis_group_interface::sum_partial_pure_heights (me, start, end);
 
@@ skipping 341 matching lines @@
                                 vector<Real> const &other_padding,
                                 vector<Real> const &other_horizon_padding,
                                 Direction const dir)
 {
   assert (other_v_skylines.size () == other_padding.size ());
   assert (other_v_skylines.size () == other_horizon_padding.size ());
   vector<Interval> forbidden_intervals;
   for (vsize j = 0; j < other_v_skylines.size (); j++)
     {
       Skyline_pair const &v_other = other_v_skylines[j];
-      Real pad = max (padding, other_padding[j]);
-      Real horizon_pad = max (horizon_padding, other_horizon_padding[j]);
+      Real pad = std::max (padding, other_padding[j]);
+      Real horizon_pad = std::max (horizon_padding, other_horizon_padding[j]);
 
       // We need to push elt up by at least this much to be above v_other.
       Real up = (*v_skyline)[DOWN].distance (v_other[UP], horizon_pad) + pad;
       // We need to push elt down by at least this much to be below v_other.
       Real down = (*v_skyline)[UP].distance (v_other[DOWN], horizon_pad) + pad;
 
       forbidden_intervals.push_back (Interval (-down, up));
     }
 
   Interval_set allowed_shifts
@@ skipping 130 matching lines @@
                                           (*all_v_skylines)[dir],
                                           (*all_paddings)[dir],
                                           (*all_horizon_paddings)[dir],
                                           dir);
 
           elt->set_property ("outside-staff-priority", SCM_BOOL_F);
           (*all_v_skylines)[dir].push_back (v_skylines);
           (*all_paddings)[dir].push_back (padding);
           (*all_horizon_paddings)[dir].push_back (horizon_padding);
         }
-      swap (elements, skipped_elements);
+      std::swap (elements, skipped_elements);
       skipped_elements.clear ();
     }
 }
 
 // If the Grob has a Y-ancestor with outside-staff-priority, return it.
 // Otherwise, return 0.
 Grob *
 Axis_group_interface::outside_staff_ancestor (Grob *me)
 {
   Grob *parent = me->get_parent (Y_AXIS);
@@ skipping 201 matching lines @@
                "pure-relevant-items "
                "pure-relevant-spanners "
                "pure-Y-common "
                "staff-affinity "
                "staff-grouper "
                "staff-staff-spacing "
                "system-Y-offset "
                "X-common "
                "Y-common "
               );