update boost to 1.44

[features.git] / boost / boost / detail / algorithm.hpp

diff --git a/boost/boost/detail/algorithm.hpp b/boost/boost/detail/algorithm.hpp
index 252e9f461c54e2d4573bbbc28933ff9c419a17f3..3f9297bcab99ff6c260b1c96441111a6a177fe59 100644 (file)
--- a/boost/boost/detail/algorithm.hpp
+++ b/boost/boost/detail/algorithm.hpp
@@ -40,115 +40,30 @@
 
 #include <algorithm>
 #include <vector>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/range/algorithm/sort.hpp>
+#include <boost/range/algorithm/stable_sort.hpp>
+#include <boost/range/algorithm/find_if.hpp>
+#include <boost/range/algorithm/count.hpp>
+#include <boost/range/algorithm/count_if.hpp>
+#include <boost/range/algorithm_ext/is_sorted.hpp>
+#include <boost/range/algorithm_ext/iota.hpp>
 
 namespace boost {
 
-  template <typename Iter1, typename Iter2>
-  Iter1 begin(const std::pair<Iter1, Iter2>& p) { return p.first; }
-
-  template <typename Iter1, typename Iter2>
-  Iter2 end(const std::pair<Iter1, Iter2>& p) { return p.second; }
-
-  template <typename Iter1, typename Iter2>
-  typename boost::detail::iterator_traits<Iter1>::difference_type
-  size(const std::pair<Iter1, Iter2>& p) {
-    return std::distance(p.first, p.second);
-  }
-
-#if 0
-  // These seem to interfere with the std::pair overloads :(
-  template <typename Container>
-  typename Container::iterator
-  begin(Container& c) { return c.begin(); }
-
-  template <typename Container>
-  typename Container::const_iterator
-  begin(const Container& c) { return c.begin(); }
-
-  template <typename Container>
-  typename Container::iterator
-  end(Container& c) { return c.end(); }
-
-  template <typename Container>
-  typename Container::const_iterator
-  end(const Container& c) { return c.end(); }
-
-  template <typename Container>
-  typename Container::size_type
-  size(const Container& c) { return c.size(); }
-#else
-  template <typename T>
-  typename std::vector<T>::iterator
-  begin(std::vector<T>& c) { return c.begin(); }
-
-  template <typename T>
-  typename std::vector<T>::const_iterator
-  begin(const std::vector<T>& c) { return c.begin(); }
-
-  template <typename T>
-  typename std::vector<T>::iterator
-  end(std::vector<T>& c) { return c.end(); }
-
-  template <typename T>
-  typename std::vector<T>::const_iterator
-  end(const std::vector<T>& c) { return c.end(); }
-
-  template <typename T>
-  typename std::vector<T>::size_type
-  size(const std::vector<T>& c) { return c.size(); }
-#endif
-  
-  template <class ForwardIterator, class T>
-  void iota(ForwardIterator first, ForwardIterator last, T value)
-  {
-    for (; first != last; ++first, ++value)
-      *first = value;
-  }
-  template <typename Container, typename T>
-  void iota(Container& c, const T& value)
-  {
-    iota(begin(c), end(c), value);
-  }
- 
-  // Also do version with 2nd container?
-  template <typename Container, typename OutIter>
-  OutIter copy(const Container& c, OutIter result) {
-    return std::copy(begin(c), end(c), result);
-  }
-
-  template <typename Container1, typename Container2>
-  bool equal(const Container1& c1, const Container2& c2)
-  {
-    if (size(c1) != size(c2))
-      return false;
-    return std::equal(begin(c1), end(c1), begin(c2));
-  }
-
-  template <typename Container>
-  void sort(Container& c) { std::sort(begin(c), end(c)); }
-
-  template <typename Container, typename Predicate>
-  void sort(Container& c, const Predicate& p) { 
-    std::sort(begin(c), end(c), p);
-  }
-
-  template <typename Container>
-  void stable_sort(Container& c) { std::stable_sort(begin(c), end(c)); }
-
-  template <typename Container, typename Predicate>
-  void stable_sort(Container& c, const Predicate& p) { 
-    std::stable_sort(begin(c), end(c), p);
-  }
-
   template <typename InputIterator, typename Predicate>
   bool any_if(InputIterator first, InputIterator last, Predicate p)
   {
     return std::find_if(first, last, p) != last;
   }
+
   template <typename Container, typename Predicate>
   bool any_if(const Container& c, Predicate p)
   {
-    return any_if(begin(c), end(c), p);
+    return any_if(boost::begin(c), boost::end(c), p);
   }
 
   template <typename InputIterator, typename T>
@@ -159,62 +74,7 @@ namespace boost {
   template <typename Container, typename T>
   bool container_contains(const Container& c, const T& value)
   {
-    return container_contains(begin(c), end(c), value);
-  }
-
-  template <typename Container, typename T>
-  std::size_t count(const Container& c, const T& value)
-  {
-    return std::count(begin(c), end(c), value);
-  }
-
-  template <typename Container, typename Predicate>
-  std::size_t count_if(const Container& c, Predicate p)
-  {
-    return std::count_if(begin(c), end(c), p);
-  }
-
-  template <typename ForwardIterator>
-  bool is_sorted(ForwardIterator first, ForwardIterator last)
-  {
-    if (first == last)
-      return true;
-
-    ForwardIterator next = first;
-    for (++next; next != last; first = next, ++next) {
-      if (*next < *first)
-        return false;
-    }
-
-    return true;
-  }
-
-  template <typename ForwardIterator, typename StrictWeakOrdering>
-  bool is_sorted(ForwardIterator first, ForwardIterator last,
-                 StrictWeakOrdering comp)
-  {
-    if (first == last)
-      return true;
-
-    ForwardIterator next = first;
-    for (++next; next != last; first = next, ++next) {
-      if (comp(*next, *first))
-        return false;
-    }
-
-    return true;
-  }
-
-  template <typename Container>
-  bool is_sorted(const Container& c)
-  {
-    return is_sorted(begin(c), end(c));
-  }
-
-  template <typename Container, typename StrictWeakOrdering>
-  bool is_sorted(const Container& c, StrictWeakOrdering comp)
-  {
-    return is_sorted(begin(c), end(c), comp);
+    return container_contains(boost::begin(c), boost::end(c), value);
   }
 
 } // namespace boost