--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imgtools/imglib/boostlibrary/boost/detail/algorithm.hpp Mon May 10 19:54:49 2010 +0100
@@ -0,0 +1,222 @@
+// (C) Copyright Jeremy Siek 2001.
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef BOOST_ALGORITHM_HPP
+# define BOOST_ALGORITHM_HPP
+# include <boost/detail/iterator.hpp>
+// Algorithms on sequences
+//
+// The functions in this file have not yet gone through formal
+// review, and are subject to change. This is a work in progress.
+// They have been checked into the detail directory because
+// there are some graph algorithms that use these functions.
+
+#include <algorithm>
+#include <vector>
+
+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);
+ }
+
+ template <typename InputIterator, typename T>
+ bool container_contains(InputIterator first, InputIterator last, T value)
+ {
+ return std::find(first, last, value) != last;
+ }
+ 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);
+ }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_HPP