Tidy code: use return statements to shorten functions, indentation, shorten auxiliary function calls avoiding ADL.

include/boost/container/experimental/segmented_copy.hpp

@@ -31,29 +31,29 @@ OutIter segmented_copy(InIter first, Sent last, OutIter result);
 namespace detail_algo {
 
 template <class SegIter, class OutIter>
-OutIter segmented_copy_dispatch
-   (SegIter first, SegIter last, OutIter result, segmented_iterator_tag)
+OutIter segmented_copy_dispatch(SegIter first, SegIter last, OutIter result, segmented_iterator_tag)
 {
    typedef segmented_iterator_traits<SegIter> traits;
    typename traits::segment_iterator sfirst = traits::segment(first);
    typename traits::segment_iterator slast  = traits::segment(last);
+
    if(sfirst == slast) {
-      result = boost::container::segmented_copy(traits::local(first), traits::local(last), result);
+      return boost::container::segmented_copy(traits::local(first), traits::local(last), result);
    }
    else {
       result = boost::container::segmented_copy(traits::local(first), traits::end(sfirst), result);
+
       for(++sfirst; sfirst != slast; ++sfirst)
          result = boost::container::segmented_copy(traits::begin(sfirst), traits::end(sfirst), result);
-      result = boost::container::segmented_copy(traits::begin(sfirst), traits::local(last), result);
+
+      return boost::container::segmented_copy(traits::begin(sfirst), traits::local(last), result);
    }
-   return result;
 }
 
 template <class InIter, class Sent, class OutIter, class Tag>
 typename algo_enable_if_c<
    !Tag::value || is_sentinel<Sent, InIter>::value, OutIter>::type
-segmented_copy_dispatch
-   (InIter first, Sent last, OutIter result, Tag)
+   segmented_copy_dispatch(InIter first, Sent last, OutIter result, Tag)
 {
    for(; first != last; ++first, ++result)
       *result = *first;
@@ -65,7 +65,8 @@ segmented_copy_dispatch
 //! Copies elements from [first, last) to the range beginning at \c result.
 //! Segmentation is exploited on the input range only.
 template <class InIter, class Sent, class OutIter>
-BOOST_CONTAINER_FORCEINLINE OutIter segmented_copy(InIter first, Sent last, OutIter result)
+BOOST_CONTAINER_FORCEINLINE
+OutIter segmented_copy(InIter first, Sent last, OutIter result)
 {
    typedef segmented_iterator_traits<InIter> traits;
    return detail_algo::segmented_copy_dispatch(first, last, result,

include/boost/container/experimental/segmented_copy_if.hpp

@@ -57,15 +57,16 @@ OutIter segmented_copy_if_dispatch
    segment_iterator slast  = traits::segment(last);
 
    if(sfirst == slast) {
-      result = (segmented_copy_if_dispatch)(traits::local(first), traits::local(last), result, pred, is_local_seg_t());
+      return (segmented_copy_if_dispatch)(traits::local(first), traits::local(last), result, pred, is_local_seg_t());
    }
    else {
       result = (segmented_copy_if_dispatch)(traits::local(first), traits::end(sfirst), result, pred, is_local_seg_t());
+
       for(++sfirst; sfirst != slast; ++sfirst)
          result = (segmented_copy_if_dispatch)(traits::begin(sfirst), traits::end(sfirst), result, pred, is_local_seg_t());
-      result = (segmented_copy_if_dispatch)(traits::begin(sfirst), traits::local(last), result, pred, is_local_seg_t());
+
+      return (segmented_copy_if_dispatch)(traits::begin(sfirst), traits::local(last), result, pred, is_local_seg_t());
    }
-   return result;
 }
 
 } // namespace detail_algo
@@ -73,7 +74,8 @@ OutIter segmented_copy_if_dispatch
 //! Copies elements satisfying \c pred from [first, last) to the range
 //! beginning at \c result. Segmentation is exploited on the input range.
 template <class InIter, class Sent, class OutIter, class Pred>
-BOOST_CONTAINER_FORCEINLINE OutIter segmented_copy_if(InIter first, Sent last, OutIter result, Pred pred)
+BOOST_CONTAINER_FORCEINLINE
+OutIter segmented_copy_if(InIter first, Sent last, OutIter result, Pred pred)
 {
    typedef segmented_iterator_traits<InIter> traits;
    return detail_algo::segmented_copy_if_dispatch(first, last, result, pred,

include/boost/container/experimental/segmented_copy_n.hpp

@@ -64,7 +64,7 @@ BOOST_CONTAINER_FORCEINLINE OutIter copy_n_scan(InIter first, InIter last, Size&
 template <class SegIt, class Size, class OutIter>
 OutIter copy_n_scan(SegIt first, SegIt last, Size& count, OutIter result, segmented_iterator_tag)
 {
-   typedef segmented_iterator_traits<SegIt> traits;
+   typedef segmented_iterator_traits<SegIt>  traits;
    typedef typename traits::local_iterator   local_iterator;
    typedef typename traits::segment_iterator segment_iterator;
    typedef typename segmented_iterator_traits<local_iterator>::is_segmented_iterator is_local_seg_t;
@@ -74,16 +74,16 @@ OutIter copy_n_scan(SegIt first, SegIt last, Size& count, OutIter result, segmen
    local_iterator   lcur  = traits::local(first);
 
    if(scur == slast) {
-      result = copy_n_scan(lcur, traits::local(last), count, result, is_local_seg_t());
+      return copy_n_scan(lcur, traits::local(last), count, result, is_local_seg_t());
    }
    else {
       result = copy_n_scan(lcur, traits::end(scur), count, result, is_local_seg_t());
+
       for(++scur; scur != slast && count > 0; ++scur)
          result = copy_n_scan(traits::begin(scur), traits::end(scur), count, result, is_local_seg_t());
-      if(count > 0)
-         result = copy_n_scan(traits::begin(scur), traits::local(last), count, result, is_local_seg_t());
+
+      return count ? copy_n_scan(traits::begin(scur), traits::local(last), count, result, is_local_seg_t()) : result;
    }
-   return result;
 }
 
 template <class SegIter, class Size, class OutIter>
@@ -126,7 +126,8 @@ OutIter segmented_copy_n_dispatch
 //! Copies \c count elements from the range beginning at \c first to
 //! the range beginning at \c result. Exploits segmentation on input.
 template <class InIter, class Size, class OutIter>
-BOOST_CONTAINER_FORCEINLINE OutIter segmented_copy_n(InIter first, Size count, OutIter result)
+BOOST_CONTAINER_FORCEINLINE
+OutIter segmented_copy_n(InIter first, Size count, OutIter result)
 {
    typedef segmented_iterator_traits<InIter> traits;
    return detail_algo::segmented_copy_n_dispatch(first, count, result,

include/boost/container/experimental/segmented_count.hpp

@@ -29,8 +29,9 @@ namespace container {
 
 //! Returns the number of elements equal to \c value in [first, last).
 template <class InpIter, class Sent, class T>
-BOOST_CONTAINER_FORCEINLINE typename boost::container::iterator_traits<InpIter>::difference_type
-segmented_count(InpIter first, Sent last, const T& value)
+BOOST_CONTAINER_FORCEINLINE
+typename boost::container::iterator_traits<InpIter>::difference_type
+   segmented_count(InpIter first, Sent last, const T& value)
 {
    return boost::container::segmented_count_if(first, last, equal_to_value<T>(value));
 }

include/boost/container/experimental/segmented_count_if.hpp

@@ -34,25 +34,26 @@ namespace detail_algo {
 
 template <class SegIter, class Pred>
 typename boost::container::iterator_traits<SegIter>::difference_type
-segmented_count_if_dispatch
-   (SegIter first, SegIter last, Pred pred, segmented_iterator_tag)
+   segmented_count_if_dispatch(SegIter first, SegIter last, Pred pred, segmented_iterator_tag)
 {
    typedef segmented_iterator_traits<SegIter> traits;
-   typedef typename boost::container::iterator_traits<SegIter>::difference_type diff_t;
-   diff_t result = 0;
+   typedef typename traits::segment_iterator  segment_iterator;
+
+   segment_iterator sfirst = traits::segment(first);
+   segment_iterator slast  = traits::segment(last);
 
-   typename traits::segment_iterator sfirst = traits::segment(first);
-   typename traits::segment_iterator slast  = traits::segment(last);
    if(sfirst == slast) {
-      result = boost::container::segmented_count_if(traits::local(first), traits::local(last), pred);
+      return (segmented_count_if)(traits::local(first), traits::local(last), pred);
    }
    else {
-      result += boost::container::segmented_count_if(traits::local(first), traits::end(sfirst), pred);
+      typename boost::container::iterator_traits<SegIter>::difference_type result = 0;
+      result += (segmented_count_if)(traits::local(first), traits::end(sfirst), pred);
+
       for(++sfirst; sfirst != slast; ++sfirst)
-         result += boost::container::segmented_count_if(traits::begin(sfirst), traits::end(sfirst), pred);
-      result += boost::container::segmented_count_if(traits::begin(sfirst), traits::local(last), pred);
+         result += (segmented_count_if)(traits::begin(sfirst), traits::end(sfirst), pred);
+
+      return result += (segmented_count_if)(traits::begin(sfirst), traits::local(last), pred);
    }
-   return result;
 }
 
 template <class InpIter, class Sent, class Pred, class Tag>

include/boost/container/experimental/segmented_equal.hpp

@@ -31,16 +31,16 @@ bool segmented_equal(InpIter1 first1, Sent last1, InpIter2 first2);
 namespace detail_algo {
 
 template <class InpIter1, class Sent, class InpIter2>
-bool equal_ref(InpIter1 first1, Sent last1, InpIter2& first2)
+bool equal_ref(InpIter1 first1, Sent last1, InpIter2& first2_out)
 {
-   InpIter2 local_first2 = first2;
-   for (; first1 != last1; ++first1, ++local_first2){
-      if (!(*first1 == *local_first2)) {
-         first2 = local_first2;
+   InpIter2 first2 = first2_out;
+   for (; first1 != last1; ++first1, ++first2){
+      if (!(*first1 == *first2)) {
+         first2_out = first2;
          return false;
       }
    }
-   first2 = local_first2;
+   first2_out = first2;
    return true;
 }
 
@@ -51,26 +51,26 @@ bool segmented_equal_ref
    typedef segmented_iterator_traits<SegIter> traits;
    typename traits::segment_iterator sfirst = traits::segment(first1);
    typename traits::segment_iterator slast  = traits::segment(last1);
+
    if(sfirst == slast) {
-      return detail_algo::equal_ref(traits::local(first1), traits::local(last1), first2);
+      return (equal_ref)(traits::local(first1), traits::local(last1), first2);
    }
    else {
-      if(!detail_algo::equal_ref(traits::local(first1), traits::end(sfirst), first2))
+      if(!(equal_ref)(traits::local(first1), traits::end(sfirst), first2))
          return false;
       for(++sfirst; sfirst != slast; ++sfirst)
-         if(!detail_algo::equal_ref(traits::begin(sfirst), traits::end(sfirst), first2))
+         if(!(equal_ref)(traits::begin(sfirst), traits::end(sfirst), first2))
             return false;
-      return detail_algo::equal_ref(traits::begin(sfirst), traits::local(last1), first2);
+      return (equal_ref)(traits::begin(sfirst), traits::local(last1), first2);
    }
 }
 
 template <class InpIter1, class Sent, class InpIter2, class Tag>
 BOOST_CONTAINER_FORCEINLINE typename algo_enable_if_c<
    !Tag::value || is_sentinel<Sent, InpIter1>::value, bool>::type
-segmented_equal_ref
-   (InpIter1 first1, Sent last1, InpIter2& first2, Tag)
+segmented_equal_ref(InpIter1 first1, Sent last1, InpIter2 first2, Tag)
 {
-   return detail_algo::equal_ref(first1, last1, first2);
+   return (equal_ref)(first1, last1, first2);
 }
 
 } // namespace detail_algo
@@ -78,11 +78,11 @@ segmented_equal_ref
 //! Returns \c true if elements in [first1, last1) are equal to the
 //! range starting at \c first2. Exploits segmentation on the first range.
 template <class InpIter1, class Sent, class InpIter2>
-BOOST_CONTAINER_FORCEINLINE bool segmented_equal(InpIter1 first1, Sent last1, InpIter2 first2)
+BOOST_CONTAINER_FORCEINLINE
+bool segmented_equal(InpIter1 first1, Sent last1, InpIter2 first2)
 {
    typedef segmented_iterator_traits<InpIter1> traits;
-   return detail_algo::segmented_equal_ref(first1, last1, first2,
-      typename traits::is_segmented_iterator());
+   return detail_algo::segmented_equal_ref(first1, last1, first2, typename traits::is_segmented_iterator());
 }
 
 } // namespace container

include/boost/container/experimental/segmented_fill.hpp

@@ -30,7 +30,8 @@ namespace container {
 //! When \c Iter is a segmented iterator, exploits segmentation
 //! to reduce per-element overhead.
 template <class FwdIt, class Sent, class T>
-BOOST_CONTAINER_FORCEINLINE void segmented_fill(FwdIt first, Sent last, const T& value)
+BOOST_CONTAINER_FORCEINLINE
+void segmented_fill(FwdIt first, Sent last, const T& value)
 {
    (segmented_generate)(first, last, detail_algo::constref_generator<T>(value));
 }

include/boost/container/experimental/segmented_fill_n.hpp

@@ -30,9 +30,10 @@ namespace container {
 //! Returns an iterator past the last filled element.
 //! Exploits segmentation when available.
 template <class FwdIt, class Size, class T>
-BOOST_CONTAINER_FORCEINLINE FwdIt segmented_fill_n(FwdIt first, Size count, const T& value)
+BOOST_CONTAINER_FORCEINLINE
+FwdIt segmented_fill_n(FwdIt first, Size count, const T& value)
 {
-   return segmented_generate_n(first, count, detail_algo::constref_generator<T>(value));
+   return (segmented_generate_n)(first, count, detail_algo::constref_generator<T>(value));
 }
 
 } // namespace container

include/boost/container/experimental/segmented_find.hpp

@@ -29,7 +29,8 @@ namespace container {
 //! Returns an iterator to the first element equal to \c value
 //! in [first, last), or \c last if not found.
 template <class InpIter, class Sent, class T>
-BOOST_CONTAINER_FORCEINLINE InpIter segmented_find(InpIter first, Sent last, const T& value)
+BOOST_CONTAINER_FORCEINLINE
+InpIter segmented_find(InpIter first, Sent last, const T& value)
 {
    return boost::container::segmented_find_if(first, last, equal_to_value<T>(value));
 }

include/boost/container/experimental/segmented_find_if.hpp

@@ -42,31 +42,35 @@ SegIter segmented_find_if_dispatch
 
    segment_iterator       sfirst = traits::segment(first);
    const segment_iterator slast  = traits::segment(last);
-   const local_iterator lf = traits::local(first);
+   const local_iterator      lf  = traits::local(first);
 
    if(sfirst == slast) {
       const local_iterator ll = traits::local(last);
       local_iterator r = (segmented_find_if)(lf, ll, pred);
-      return (r != ll) ? traits::compose(sfirst, r) : last;
+      if (r != ll)
+         return traits::compose(sfirst, r);
    }
    else {
       //First segment
       {
          const local_iterator le = traits::end(sfirst);
          const local_iterator r = (segmented_find_if)(lf, le, pred);
-         if (r != le) return traits::compose(sfirst, r);
+         if (r != le)
+            return traits::compose(sfirst, r);
       }
       //Middle segments
       for (++sfirst; sfirst != slast; ++sfirst) {
          const local_iterator le = traits::end(sfirst);
          const local_iterator r = (segmented_find_if)(traits::begin(sfirst), le, pred);
-         if (r != le) return traits::compose(sfirst, r);
+         if (r != le)
+            return traits::compose(sfirst, r);
       }
       //Last segment
       {
          const local_iterator ll = traits::local(last);
          const local_iterator r = (segmented_find_if)(traits::begin(sfirst), ll, pred);
-         if (r != ll) return traits::compose(sfirst, r);
+         if (r != ll)
+            return traits::compose(sfirst, r);
       }
    }
    return last;
@@ -75,8 +79,7 @@ SegIter segmented_find_if_dispatch
 template <class InpIter, class Sent, class Pred, class Tag>
 typename algo_enable_if_c<
    !Tag::value || is_sentinel<Sent, InpIter>::value, InpIter>::type
-segmented_find_if_dispatch
-   (InpIter first, Sent last, Pred pred, Tag)
+segmented_find_if_dispatch(InpIter first, Sent last, Pred pred, Tag)
 {
    for(; first != last; ++first)
       if(pred(*first))
@@ -89,11 +92,11 @@ segmented_find_if_dispatch
 //! Returns an iterator to the first element satisfying \c pred
 //! in [first, last), or \c last if not found.
 template <class InpIter, class Sent, class Pred>
-BOOST_CONTAINER_FORCEINLINE InpIter segmented_find_if(InpIter first, Sent last, Pred pred)
+BOOST_CONTAINER_FORCEINLINE
+InpIter segmented_find_if(InpIter first, Sent last, Pred pred)
 {
    typedef segmented_iterator_traits<InpIter> traits;
-   return detail_algo::segmented_find_if_dispatch(first, last, pred,
-      typename traits::is_segmented_iterator());
+   return detail_algo::segmented_find_if_dispatch(first, last, pred, typename traits::is_segmented_iterator());
 }
 
 } // namespace container

include/boost/container/experimental/segmented_find_if_not.hpp

@@ -29,9 +29,10 @@ namespace container {
 //! Returns an iterator to the first element for which \c pred
 //! returns false in [first, last), or \c last if not found.
 template <class InpIter, class Sent, class Pred>
-BOOST_CONTAINER_FORCEINLINE InpIter segmented_find_if_not(InpIter first, Sent last, Pred pred)
+BOOST_CONTAINER_FORCEINLINE
+InpIter segmented_find_if_not(InpIter first, Sent last, Pred pred)
 {
-   return boost::container::segmented_find_if(first, last, not_pred<Pred>(pred));
+   return (segmented_find_if)(first, last, not_pred<Pred>(pred));
 }
 
 } // namespace container

include/boost/container/experimental/segmented_generate.hpp

@@ -47,13 +47,13 @@ void segmented_generate_ref
    typename traits::segment_iterator sfirst = traits::segment(first);
    typename traits::segment_iterator slast  = traits::segment(last);
    if(sfirst == slast) {
-      detail_algo::generate_ref(traits::local(first), traits::local(last), gen);
+      (generate_ref)(traits::local(first), traits::local(last), gen);
    }
    else {
-      detail_algo::generate_ref(traits::local(first), traits::end(sfirst), gen);
+      (generate_ref)(traits::local(first), traits::end(sfirst), gen);
       for(++sfirst; sfirst != slast; ++sfirst)
-         detail_algo::generate_ref(traits::begin(sfirst), traits::end(sfirst), gen);
-      detail_algo::generate_ref(traits::begin(sfirst), traits::local(last), gen);
+         (generate_ref)(traits::begin(sfirst), traits::end(sfirst), gen);
+      (generate_ref)(traits::begin(sfirst), traits::local(last), gen);
    }
 }
 
@@ -71,11 +71,11 @@ segmented_generate_ref(FwdIt first, Sent last, Generator& gen, Tag)
 //! element in [first, last).
 //! Generator state is preserved across segment boundaries.
 template <class FwdIt, class Sent, class Generator>
-BOOST_CONTAINER_FORCEINLINE void segmented_generate(FwdIt first, Sent last, Generator gen)
+BOOST_CONTAINER_FORCEINLINE
+void segmented_generate(FwdIt first, Sent last, Generator gen)
 {
    typedef segmented_iterator_traits<FwdIt> traits;
-   detail_algo::segmented_generate_ref(first, last, gen,
-      typename traits::is_segmented_iterator());
+   detail_algo::segmented_generate_ref(first, last, gen, typename traits::is_segmented_iterator());
 }
 
 } // namespace container

include/boost/container/experimental/segmented_generate_n.hpp

@@ -132,7 +132,8 @@ OutIt segmented_generate_n_ref
 //! preserved across segment boundaries.
 //! Returns an iterator past the last generated element.
 template <class OutIt, class Size, class Generator>
-BOOST_CONTAINER_FORCEINLINE OutIt segmented_generate_n(OutIt first, Size count, Generator gen)
+BOOST_CONTAINER_FORCEINLINE
+OutIt segmented_generate_n(OutIt first, Size count, Generator gen)
 {
    typedef segmented_iterator_traits<OutIt> traits;
    return detail_algo::segmented_generate_n_ref(first, count, gen,

include/boost/container/experimental/segmented_merge.hpp

@@ -58,22 +58,26 @@ template <class SegIt, class InIter2, class Sent2, class OutIter, class Comp>
 OutIter merge_scan(SegIt first, SegIt last, InIter2& first2, Sent2 last2, OutIter result, Comp comp,
    segmented_iterator_tag)
 {
-   typedef segmented_iterator_traits<SegIt> traits;
-   typedef typename traits::local_iterator local_iterator;
+   typedef segmented_iterator_traits<SegIt>  traits;
+   typedef typename traits::local_iterator   local_iterator;
+   typedef typename traits::segment_iterator segment_iterator;
    typedef typename segmented_iterator_traits<local_iterator>::is_segmented_iterator is_local_seg_t;
-   typename traits::segment_iterator scur  = traits::segment(first);
-   typename traits::segment_iterator slast = traits::segment(last);
+
+   segment_iterator scur  = traits::segment(first);
+   segment_iterator slast = traits::segment(last);
    local_iterator lcur = traits::local(first);
+
    if(scur == slast) {
-      merge_scan(lcur, traits::local(last), first2, last2, result, comp, is_local_seg_t());
+      return merge_scan(lcur, traits::local(last), first2, last2, result, comp, is_local_seg_t());
    }
    else {
       result = merge_scan(lcur, traits::end(scur), first2, last2, result, comp, is_local_seg_t());
+
       for(++scur; scur != slast; ++scur)
          result = merge_scan(traits::begin(scur), traits::end(scur), first2, last2, result, comp, is_local_seg_t());
-      result = merge_scan(traits::begin(scur), traits::local(last), first2, last2, result, comp, is_local_seg_t());
+
+      return merge_scan(traits::begin(scur), traits::local(last), first2, last2, result, comp, is_local_seg_t());
    }
-   return result;
 }
 
 template <class SegIter, class InIter2, class Sent2, class OutIter, class Comp>