summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2010-05-06 17:44:27 (GMT)
committerRemko Tronçon <git@el-tramo.be>2010-05-06 17:44:27 (GMT)
commitd76ada0ab59634e3333f9eb5a92d0e850f60d7bf (patch)
tree5eaae441173fad2ec19ba67d6589f28ecd740991 /3rdParty/Boost/src/boost/range
parent6f49e5abee37d37b351d68c01374232eccdac458 (diff)
downloadswift-d76ada0ab59634e3333f9eb5a92d0e850f60d7bf.zip
swift-d76ada0ab59634e3333f9eb5a92d0e850f60d7bf.tar.bz2
Updated Boost to 1.43.0.
Diffstat (limited to '3rdParty/Boost/src/boost/range')
-rwxr-xr-x3rdParty/Boost/src/boost/range/algorithm/equal.hpp188
-rw-r--r--3rdParty/Boost/src/boost/range/as_literal.hpp30
-rw-r--r--3rdParty/Boost/src/boost/range/concepts.hpp331
-rw-r--r--3rdParty/Boost/src/boost/range/const_iterator.hpp11
-rwxr-xr-x3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp52
-rw-r--r--3rdParty/Boost/src/boost/range/detail/implementation_help.hpp14
-rwxr-xr-x3rdParty/Boost/src/boost/range/detail/misc_concept.hpp33
-rw-r--r--3rdParty/Boost/src/boost/range/iterator.hpp64
-rw-r--r--3rdParty/Boost/src/boost/range/iterator_range.hpp659
-rwxr-xr-x3rdParty/Boost/src/boost/range/iterator_range_core.hpp542
-rwxr-xr-x3rdParty/Boost/src/boost/range/iterator_range_io.hpp93
-rw-r--r--3rdParty/Boost/src/boost/range/mutable_iterator.hpp11
-rw-r--r--3rdParty/Boost/src/boost/range/size.hpp2
-rw-r--r--3rdParty/Boost/src/boost/range/size_type.hpp3
14 files changed, 1318 insertions, 715 deletions
diff --git a/3rdParty/Boost/src/boost/range/algorithm/equal.hpp b/3rdParty/Boost/src/boost/range/algorithm/equal.hpp
new file mode 100755
index 0000000..7226440
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/algorithm/equal.hpp
@@ -0,0 +1,188 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/range/concepts.hpp>
+#include <iterator>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ // An implementation of equality comparison that is optimized for iterator
+ // traversal categories less than RandomAccessTraversal.
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class IteratorCategoryTag1,
+ class IteratorCategoryTag2 >
+ inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ IteratorCategoryTag1,
+ IteratorCategoryTag2 )
+ {
+ do
+ {
+ // If we have reached the end of the left range then this is
+ // the end of the loop. They are equal if and only if we have
+ // simultaneously reached the end of the right range.
+ if (first1 == last1)
+ return first2 == last2;
+
+ // If we have reached the end of the right range at this line
+ // it indicates that the right range is shorter than the left
+ // and hence the result is false.
+ if (first2 == last2)
+ return false;
+
+ // continue looping if and only if the values are equal
+ } while(*first1++ == *first2++);
+
+ // Reaching this line in the algorithm indicates that a value
+ // inequality has been detected.
+ return false;
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class IteratorCategoryTag1,
+ class IteratorCategoryTag2,
+ class BinaryPredicate >
+ inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ BinaryPredicate pred,
+ IteratorCategoryTag1,
+ IteratorCategoryTag2 )
+ {
+ do
+ {
+ // If we have reached the end of the left range then this is
+ // the end of the loop. They are equal if and only if we have
+ // simultaneously reached the end of the right range.
+ if (first1 == last1)
+ return first2 == last2;
+
+ // If we have reached the end of the right range at this line
+ // it indicates that the right range is shorter than the left
+ // and hence the result is false.
+ if (first2 == last2)
+ return false;
+
+ // continue looping if and only if the values are equal
+ } while(pred(*first1++, *first2++));
+
+ // Reaching this line in the algorithm indicates that a value
+ // inequality has been detected.
+ return false;
+ }
+
+ // An implementation of equality comparison that is optimized for
+ // random access iterators.
+ template< class RandomAccessTraversalReadableIterator1,
+ class RandomAccessTraversalReadableIterator2 >
+ inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+ RandomAccessTraversalReadableIterator1 last1,
+ RandomAccessTraversalReadableIterator2 first2,
+ RandomAccessTraversalReadableIterator2 last2,
+ std::random_access_iterator_tag,
+ std::random_access_iterator_tag )
+ {
+ return ((last1 - first1) == (last2 - first2))
+ && std::equal(first1, last1, first2);
+ }
+
+ template< class RandomAccessTraversalReadableIterator1,
+ class RandomAccessTraversalReadableIterator2,
+ class BinaryPredicate >
+ inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+ RandomAccessTraversalReadableIterator1 last1,
+ RandomAccessTraversalReadableIterator2 first2,
+ RandomAccessTraversalReadableIterator2 last2,
+ BinaryPredicate pred )
+ {
+ return ((last1 - first1) == (last2 - first2))
+ && std::equal(first1, last1, first2, pred);
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2 >
+ inline bool equal( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2 )
+ {
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+
+ return equal_impl(first1, last1, first2, last2, tag1, tag2);
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class BinaryPredicate >
+ inline bool equal( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ BinaryPredicate pred )
+ {
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+
+ return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
+ }
+
+ } // namespace range_detail
+
+ namespace range
+ {
+
+ /// \brief template function equal
+ ///
+ /// range-based version of the equal std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+ return ::boost::range_detail::equal(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2) );
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+ BinaryPredicate pred )
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+ return ::boost::range_detail::equal(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2),
+ pred);
+ }
+
+ } // namespace range
+ using range::equal;
+} // namespace boost
+
+#endif // include guard
diff --git a/3rdParty/Boost/src/boost/range/as_literal.hpp b/3rdParty/Boost/src/boost/range/as_literal.hpp
index 2f04ca8..f67ead7 100644
--- a/3rdParty/Boost/src/boost/range/as_literal.hpp
+++ b/3rdParty/Boost/src/boost/range/as_literal.hpp
@@ -25,7 +25,7 @@
#include <boost/detail/workaround.hpp>
#include <cstring>
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR
#include <cwchar>
#endif
@@ -38,41 +38,41 @@ namespace boost
return strlen( s );
}
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR
inline std::size_t length( const wchar_t* s )
{
return wcslen( s );
}
-#endif
+#endif
//
// Remark: the compiler cannot choose between T* and T[sz]
// overloads, so we must put the T* internal to the
// unconstrained version.
- //
+ //
inline bool is_char_ptr( char* )
{
return true;
}
-
+
inline bool is_char_ptr( const char* )
{
return true;
}
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR
inline bool is_char_ptr( wchar_t* )
{
return true;
}
-
+
inline bool is_char_ptr( const wchar_t* )
{
return true;
}
#endif
-
+
template< class T >
inline long is_char_ptr( T /* r */ )
{
@@ -80,30 +80,30 @@ namespace boost
}
template< class T >
- inline iterator_range<T*>
+ inline iterator_range<T*>
make_range( T* const r, bool )
{
return iterator_range<T*>( r, r + length(r) );
}
template< class T >
- inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type>
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type>
make_range( T& r, long )
{
return boost::make_iterator_range( r );
}
}
-
+
template< class Range >
- inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
as_literal( Range& r )
{
return range_detail::make_range( r, range_detail::is_char_ptr(r) );
}
template< class Range >
- inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
as_literal( const Range& r )
{
return range_detail::make_range( r, range_detail::is_char_ptr(r) );
@@ -112,9 +112,9 @@ namespace boost
template< class Char, std::size_t sz >
inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
{
- return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
+ return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
}
-
+
template< class Char, std::size_t sz >
inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
{
diff --git a/3rdParty/Boost/src/boost/range/concepts.hpp b/3rdParty/Boost/src/boost/range/concepts.hpp
new file mode 100644
index 0000000..8e4d2cf
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/concepts.hpp
@@ -0,0 +1,331 @@
+// Boost.Range library concept checks
+//
+// Copyright Neil Groves 2009. Use, modification and distribution
+// are subject to the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Copyright Daniel Walker 2006. Use, modification and distribution
+// are subject to the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_CONCEPTS_HPP
+#define BOOST_RANGE_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/detail/misc_concept.hpp>
+
+/*!
+ * \file
+ * \brief Concept checks for the Boost Range library.
+ *
+ * The structures in this file may be used in conjunction with the
+ * Boost Concept Check library to insure that the type of a function
+ * parameter is compatible with a range concept. If not, a meaningful
+ * compile time error is generated. Checks are provided for the range
+ * concepts related to iterator traversal categories. For example, the
+ * following line checks that the type T models the ForwardRange
+ * concept.
+ *
+ * \code
+ * BOOST_CONCEPT_ASSERT((ForwardRangeConcept<T>));
+ * \endcode
+ *
+ * A different concept check is required to ensure writeable value
+ * access. For example to check for a ForwardRange that can be written
+ * to, the following code is required.
+ *
+ * \code
+ * BOOST_CONCEPT_ASSERT((WriteableForwardRangeConcept<T>));
+ * \endcode
+ *
+ * \see http://www.boost.org/libs/range/doc/range.html for details
+ * about range concepts.
+ * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
+ * for details about iterator concepts.
+ * \see http://www.boost.org/libs/concept_check/concept_check.htm for
+ * details about concept checks.
+ */
+
+namespace boost {
+
+ namespace range_detail {
+
+#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+
+// List broken compiler versions here:
+ #ifdef __GNUC__
+ // GNUC 4.2 has strange issues correctly detecting compliance with the Concepts
+ // hence the least disruptive approach is to turn-off the concept checking for
+ // this version of the compiler.
+ #if __GNUC__ == 4 && __GNUC_MINOR__ == 2
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+ #endif
+
+ #ifdef __BORLANDC__
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+
+ #ifdef __PATHCC__
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+
+// Default to using the concept asserts unless we have defined it off
+// during the search for black listed compilers.
+ #ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 1
+ #endif
+
+#endif
+
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ #define BOOST_RANGE_CONCEPT_ASSERT( x ) BOOST_CONCEPT_ASSERT( x )
+#else
+ #define BOOST_RANGE_CONCEPT_ASSERT( x )
+#endif
+
+ // Rationale for the inclusion of redefined iterator concept
+ // classes:
+ //
+ // The Range algorithms often do not require that the iterators are
+ // Assignable, but the correct standard conformant iterators
+ // do require the iterators to be a model of the Assignable concept.
+ // Iterators that contains a functor that is not assignable therefore
+ // are not correct models of the standard iterator concepts,
+ // despite being adequate for most algorithms. An example of this
+ // use case is the combination of the boost::adaptors::filtered
+ // class with a boost::lambda::bind generated functor.
+ // Ultimately modeling the range concepts using composition
+ // with the Boost.Iterator concepts would render the library
+ // incompatible with many common Boost.Lambda expressions.
+ template<class Iterator>
+ struct IncrementableIteratorConcept : CopyConstructible<Iterator>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
+
+ BOOST_RANGE_CONCEPT_ASSERT((
+ Convertible<
+ traversal_category,
+ incrementable_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(IncrementableIteratorConcept)
+ {
+ ++i;
+ (void)i++;
+ }
+ private:
+ Iterator i;
+#endif
+ };
+
+ template<class Iterator>
+ struct SinglePassIteratorConcept
+ : IncrementableIteratorConcept<Iterator>
+ , EqualityComparable<Iterator>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
+ Convertible<
+ BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
+ single_pass_traversal_tag
+ >));
+#endif
+ };
+
+ template<class Iterator>
+ struct ForwardIteratorConcept
+ : SinglePassIteratorConcept<Iterator>
+ , DefaultConstructible<Iterator>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+
+ BOOST_MPL_ASSERT((is_integral<difference_type>));
+ BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+
+ BOOST_RANGE_CONCEPT_ASSERT((
+ Convertible<
+ BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
+ forward_traversal_tag
+ >));
+#endif
+ };
+
+ template<class Iterator>
+ struct BidirectionalIteratorConcept
+ : ForwardIteratorConcept<Iterator>
+ {
+ #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
+ Convertible<
+ BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
+ bidirectional_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(BidirectionalIteratorConcept)
+ {
+ --i;
+ (void)i--;
+ }
+ private:
+ Iterator i;
+ #endif
+ };
+
+ template<class Iterator>
+ struct RandomAccessIteratorConcept
+ : BidirectionalIteratorConcept<Iterator>
+ {
+ #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
+ Convertible<
+ BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
+ random_access_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(RandomAccessIteratorConcept)
+ {
+ i += n;
+ i = i + n;
+ i = n + i;
+ i -= n;
+ i = i - n;
+ n = i - j;
+ }
+ private:
+ BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
+ Iterator i;
+ Iterator j;
+ #endif
+ };
+
+ } // namespace range_detail
+
+ //! Check if a type T models the SinglePassRange range concept.
+ template<class T>
+ struct SinglePassRangeConcept
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;
+
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
+
+ BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
+ {
+ // This has been modified from assigning to this->i
+ // (where i was a member variable) to improve
+ // compatibility with Boost.Lambda
+ iterator i1 = boost::begin(*m_range);
+ iterator i2 = boost::end(*m_range);
+
+ ignore_unused_variable_warning(i1);
+ ignore_unused_variable_warning(i2);
+
+ const_constraints(*m_range);
+ }
+
+ private:
+ void const_constraints(const T& const_range)
+ {
+ const_iterator ci1 = boost::begin(const_range);
+ const_iterator ci2 = boost::end(const_range);
+
+ ignore_unused_variable_warning(ci1);
+ ignore_unused_variable_warning(ci2);
+ }
+
+ // Rationale:
+ // The type of m_range is T* rather than T because it allows
+ // T to be an abstract class. The other obvious alternative of
+ // T& produces a warning on some compilers.
+ T* m_range;
+#endif
+ };
+
+ //! Check if a type T models the ForwardRange range concept.
+ template<class T>
+ struct ForwardRangeConcept : SinglePassRangeConcept<T>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
+#endif
+ };
+
+ template<class Range>
+ struct WriteableRangeConcept
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
+
+ BOOST_CONCEPT_USAGE(WriteableRangeConcept)
+ {
+ *i = v;
+ }
+ private:
+ iterator i;
+ BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
+#endif
+ };
+
+ //! Check if a type T models the WriteableForwardRange range concept.
+ template<class T>
+ struct WriteableForwardRangeConcept
+ : ForwardRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+ //! Check if a type T models the BidirectionalRange range concept.
+ template<class T>
+ struct BidirectionalRangeConcept : ForwardRangeConcept<T>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
+#endif
+ };
+
+ //! Check if a type T models the WriteableBidirectionalRange range concept.
+ template<class T>
+ struct WriteableBidirectionalRangeConcept
+ : BidirectionalRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+ //! Check if a type T models the RandomAccessRange range concept.
+ template<class T>
+ struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
+#endif
+ };
+
+ //! Check if a type T models the WriteableRandomAccessRange range concept.
+ template<class T>
+ struct WriteableRandomAccessRangeConcept
+ : RandomAccessRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+} // namespace boost
+
+#endif // BOOST_RANGE_CONCEPTS_HPP
diff --git a/3rdParty/Boost/src/boost/range/const_iterator.hpp b/3rdParty/Boost/src/boost/range/const_iterator.hpp
index 195f9d4..875320f 100644
--- a/3rdParty/Boost/src/boost/range/const_iterator.hpp
+++ b/3rdParty/Boost/src/boost/range/const_iterator.hpp
@@ -21,6 +21,7 @@
#include <boost/range/detail/const_iterator.hpp>
#else
+#include <boost/range/detail/extract_optional_type.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <cstddef>
#include <utility>
@@ -31,11 +32,13 @@ namespace boost
// default
//////////////////////////////////////////////////////////////////////////
+ namespace range_detail {
+ BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
+ }
+
template< typename C >
- struct range_const_iterator
- {
- typedef BOOST_DEDUCED_TYPENAME C::const_iterator type;
- };
+ struct range_const_iterator : range_detail::extract_const_iterator<C>
+ {};
//////////////////////////////////////////////////////////////////////////
// pair
diff --git a/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp b/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp
new file mode 100755
index 0000000..8292e34
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp
@@ -0,0 +1,52 @@
+// Boost.Range library
+//
+// Copyright Arno Schoedl & Neil Groves 2009.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_PARTIAL_TEMPLATE_SPECIALIZATION
+
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ template< typename C > \
+ struct extract_ ## a_typedef \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+ };
+
+#else
+
+namespace boost {
+ namespace range_detail {
+ template< typename T > struct exists { typedef void type; };
+ }
+}
+
+// Defines extract_some_typedef<T> which exposes T::some_typedef as
+// extract_some_typedef<T>::type if T::some_typedef exists. Otherwise
+// extract_some_typedef<T> is empty.
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ template< typename C, typename Enable=void > \
+ struct extract_ ## a_typedef \
+ {}; \
+ template< typename C > \
+ struct extract_ ## a_typedef< C \
+ , BOOST_DEDUCED_TYPENAME boost::range_detail::exists< BOOST_DEDUCED_TYPENAME C::a_typedef >::type \
+ > { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+ };
+
+#endif
+
+#endif // include guard
diff --git a/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp b/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp
index ca12fa4..1f7d163 100644
--- a/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp
+++ b/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp
@@ -21,13 +21,13 @@
#include <wchar.h>
#endif
-namespace boost
+namespace boost
{
namespace range_detail
{
template <typename T>
inline void boost_range_silence_warning( const T& ) { }
-
+
/////////////////////////////////////////////////////////////////////
// end() help
/////////////////////////////////////////////////////////////////////
@@ -36,7 +36,7 @@ namespace boost
{
return s + strlen( s );
}
-
+
#ifndef BOOST_NO_CWCHAR
inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
{
@@ -51,7 +51,7 @@ namespace boost
;
return s;
}
-#endif
+#endif
template< class Char >
inline Char* str_end( Char* s )
@@ -64,7 +64,7 @@ namespace boost
{
return boost_range_array + sz;
}
-
+
template< class T, std::size_t sz >
inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
{
@@ -74,7 +74,7 @@ namespace boost
/////////////////////////////////////////////////////////////////////
// size() help
/////////////////////////////////////////////////////////////////////
-
+
template< class Char >
inline std::size_t str_size( const Char* const& s )
{
@@ -96,7 +96,7 @@ namespace boost
}
} // namespace 'range_detail'
-
+
} // namespace 'boost'
diff --git a/3rdParty/Boost/src/boost/range/detail/misc_concept.hpp b/3rdParty/Boost/src/boost/range/detail/misc_concept.hpp
new file mode 100755
index 0000000..74cb919
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/detail/misc_concept.hpp
@@ -0,0 +1,33 @@
+// Boost.Range library concept checks
+//
+// Copyright Neil Groves 2009. Use, modification and distribution
+// are subject to the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template<typename T1, typename T2>
+ class SameTypeConcept
+ {
+ public:
+ BOOST_CONCEPT_USAGE(SameTypeConcept)
+ {
+ same_type(a,b);
+ }
+ private:
+ template<typename T> void same_type(T,T) {}
+ T1 a;
+ T2 b;
+ };
+ }
+}
+
+#endif // include guard
diff --git a/3rdParty/Boost/src/boost/range/iterator.hpp b/3rdParty/Boost/src/boost/range/iterator.hpp
index 21798c5..ec73ddc 100644
--- a/3rdParty/Boost/src/boost/range/iterator.hpp
+++ b/3rdParty/Boost/src/boost/range/iterator.hpp
@@ -25,46 +25,46 @@
namespace boost
{
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
- namespace range_detail_vc7_1
- {
- template< typename C, typename Sig = void(C) >
- struct range_iterator
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- mpl::eval_if_c< is_const<C>::value,
- range_const_iterator< typename remove_const<C>::type >,
- range_mutable_iterator<C> >::type type;
- };
-
- template< typename C, typename T >
- struct range_iterator< C, void(T[]) >
- {
- typedef T* type;
- };
- }
-
-#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+ namespace range_detail_vc7_1
+ {
+ template< typename C, typename Sig = void(C) >
+ struct range_iterator
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ mpl::eval_if_c< is_const<C>::value,
+ range_const_iterator< typename remove_const<C>::type >,
+ range_mutable_iterator<C> >::type type;
+ };
+
+ template< typename C, typename T >
+ struct range_iterator< C, void(T[]) >
+ {
+ typedef T* type;
+ };
+ }
+
+#endif
template< typename C >
struct range_iterator
{
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- range_detail_vc7_1::range_iterator<C>::type type;
-
-#else
-
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- mpl::eval_if_c< is_const<C>::value,
+
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ range_detail_vc7_1::range_iterator<C>::type type;
+
+#else
+
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ mpl::eval_if_c< is_const<C>::value,
range_const_iterator< typename remove_const<C>::type >,
range_mutable_iterator<C> >::type type;
-
-#endif
+
+#endif
};
-
+
} // namespace boost
//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
diff --git a/3rdParty/Boost/src/boost/range/iterator_range.hpp b/3rdParty/Boost/src/boost/range/iterator_range.hpp
index d118224..dfcd4d2 100644
--- a/3rdParty/Boost/src/boost/range/iterator_range.hpp
+++ b/3rdParty/Boost/src/boost/range/iterator_range.hpp
@@ -1,659 +1,16 @@
// Boost.Range library
//
-// Copyright Thorsten Ottosen & Pavol Droba 2003-2004. Use, modification and
-// distribution is subject to the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// Copyright Neil Groves 2009.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
-#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP
-#define BOOST_RANGE_ITERATOR_RANGE_HPP
-
-#include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
- #pragma warning( push )
- #pragma warning( disable : 4996 )
-#endif
-
-// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
-#ifndef BOOST_OLD_IOSTREAMS
-# if defined(__STL_CONFIG_H) && \
- !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
- /**/
-# define BOOST_OLD_IOSTREAMS
-# endif
-#endif // #ifndef BOOST_OLD_IOSTREAMS
-
-#include <boost/assert.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/range/functions.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/difference_type.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <iterator>
-#include <algorithm>
-#ifndef _STLP_NO_IOSTREAMS
-# ifndef BOOST_OLD_IOSTREAMS
-# include <ostream>
-# else
-# include <ostream.h>
-# endif
-#endif // _STLP_NO_IOSTREAMS
-#include <cstddef>
-
-/*! \file
- Defines the \c iterator_class and related functions.
- \c iterator_range is a simple wrapper of iterator pair idiom. It provides
- a rich subset of Container interface.
-*/
-
-
-namespace boost
-{
- namespace iterator_range_detail
- {
- //
- // The functions adl_begin and adl_end are implemented in a separate
- // class for gcc-2.9x
- //
- template<typename IteratorT>
- struct iterator_range_impl {
- template< class ForwardRange >
- static IteratorT adl_begin( ForwardRange& r )
- {
- return IteratorT( boost::begin( r ) );
- }
-
- template< class ForwardRange >
- static IteratorT adl_end( ForwardRange& r )
- {
- return IteratorT( boost::end( r ) );
- }
- };
-
- template< class Left, class Right >
- inline bool equal( const Left& l, const Right& r )
- {
- typedef BOOST_DEDUCED_TYPENAME boost::range_difference<Left>::type sz_type;
-
- sz_type l_size = boost::distance( l ),
- r_size = boost::distance( r );
-
- if( l_size != r_size )
- return false;
-
- return std::equal( boost::begin(l), boost::end(l),
- boost::begin(r) );
- }
-
- template< class Left, class Right >
- inline bool less_than( const Left& l, const Right& r )
- {
- return std::lexicographical_compare( boost::begin(l),
- boost::end(l),
- boost::begin(r),
- boost::end(r) );
- }
-
- struct range_tag { };
- struct const_range_tag { };
-
- }
-
-// iterator range template class -----------------------------------------//
-
- //! iterator_range class
- /*!
- An \c iterator_range delimits a range in a sequence by beginning and ending iterators.
- An iterator_range can be passed to an algorithm which requires a sequence as an input.
- For example, the \c toupper() function may be used most frequently on strings,
- but can also be used on iterator_ranges:
-
- \code
- boost::tolower( find( s, "UPPERCASE STRING" ) );
- \endcode
-
- Many algorithms working with sequences take a pair of iterators,
- delimiting a working range, as an arguments. The \c iterator_range class is an
- encapsulation of a range identified by a pair of iterators.
- It provides a collection interface,
- so it is possible to pass an instance to an algorithm requiring a collection as an input.
- */
- template<typename IteratorT>
- class iterator_range
- {
- protected: // Used by sub_range
- //! implementation class
- typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
- public:
-
- //! this type
- typedef iterator_range<IteratorT> type;
- //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
-
- //! Encapsulated value type
- typedef BOOST_DEDUCED_TYPENAME
- iterator_value<IteratorT>::type value_type;
-
- //! Difference type
- typedef BOOST_DEDUCED_TYPENAME
- iterator_difference<IteratorT>::type difference_type;
-
- //! Size type
- typedef std::size_t size_type; // note: must be unsigned
-
- //! This type
- typedef iterator_range<IteratorT> this_type;
-
- //! Refence type
- //
- // Needed because value-type is the same for
- // const and non-const iterators
- //
- typedef BOOST_DEDUCED_TYPENAME
- iterator_reference<IteratorT>::type reference;
-
- //! const_iterator type
- /*!
- There is no distinction between const_iterator and iterator.
- These typedefs are provides to fulfill container interface
- */
- typedef IteratorT const_iterator;
- //! iterator type
- typedef IteratorT iterator;
-
- private: // for return value of operator()()
- typedef BOOST_DEDUCED_TYPENAME
- boost::mpl::if_< boost::is_abstract<value_type>,
- reference, value_type >::type abstract_value_type;
-
- public:
- iterator_range() : m_Begin( iterator() ), m_End( iterator() )
- #ifndef NDEBUG
- , singular( true )
- #endif
- { }
-
- //! Constructor from a pair of iterators
- template< class Iterator >
- iterator_range( Iterator Begin, Iterator End ) :
- m_Begin(Begin), m_End(End)
- #ifndef NDEBUG
- , singular(false)
- #endif
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( const Range& r ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- #ifndef NDEBUG
- , singular(false)
- #endif
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( Range& r ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- #ifndef NDEBUG
- , singular(false)
- #endif
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- #ifndef NDEBUG
- , singular(false)
- #endif
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( Range& r, iterator_range_detail::range_tag ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- #ifndef NDEBUG
- , singular(false)
- #endif
- {}
-
- #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- this_type& operator=( const this_type& r )
- {
- m_Begin = r.begin();
- m_End = r.end();
-
- #ifndef NDEBUG
- singular = r.singular;
- #endif
- return *this;
- }
- #endif
-
- template< class Iterator >
- iterator_range& operator=( const iterator_range<Iterator>& r )
- {
- m_Begin = r.begin();
- m_End = r.end();
- #ifndef NDEBUG
- singular = r.is_singular();
- #endif
- return *this;
- }
-
- template< class ForwardRange >
- iterator_range& operator=( ForwardRange& r )
- {
- m_Begin = impl::adl_begin( r );
- m_End = impl::adl_end( r );
- #ifndef NDEBUG
- singular = false;
- #endif
- return *this;
- }
-
- template< class ForwardRange >
- iterator_range& operator=( const ForwardRange& r )
- {
- m_Begin = impl::adl_begin( r );
- m_End = impl::adl_end( r );
- #ifndef NDEBUG
- singular = false;
- #endif
- return *this;
- }
-
- IteratorT begin() const
- {
- BOOST_ASSERT( !is_singular() );
- return m_Begin;
- }
-
- IteratorT end() const
- {
- BOOST_ASSERT( !is_singular() );
- return m_End;
- }
-
- difference_type size() const
- {
- BOOST_ASSERT( !is_singular() );
- return m_End - m_Begin;
- }
-
- bool empty() const
- {
- BOOST_ASSERT( !is_singular() );
- return m_Begin == m_End;
- }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
- operator bool() const
- {
- return !empty();
- }
-#else
- typedef iterator (iterator_range::*unspecified_bool_type) () const;
- operator unspecified_bool_type() const
- {
- return empty() ? 0: &iterator_range::end;
- }
-#endif
-
- bool equal( const iterator_range& r ) const
- {
- BOOST_ASSERT( !is_singular() );
- return m_Begin == r.m_Begin && m_End == r.m_End;
- }
-
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- bool operator==( const iterator_range& r ) const
- {
- BOOST_ASSERT( !is_singular() );
- return iterator_range_detail::equal( *this, r );
- }
-
- bool operator!=( const iterator_range& r ) const
- {
- BOOST_ASSERT( !is_singular() );
- return !operator==(r);
- }
-
- bool operator<( const iterator_range& r ) const
- {
- BOOST_ASSERT( !is_singular() );
- return iterator_range_detail::less_than( *this, r );
- }
-
-#endif
-
- public: // convenience
- reference front() const
- {
- BOOST_ASSERT( !empty() );
- return *m_Begin;
- }
-
- reference back() const
- {
- BOOST_ASSERT( !empty() );
- IteratorT last( m_End );
- return *--last;
- }
-
- reference operator[]( difference_type at ) const
- {
- BOOST_ASSERT( at >= 0 && at < size() );
- return m_Begin[at];
- }
-
- //
- // When storing transform iterators, operator[]()
- // fails because it returns by reference. Therefore
- // operator()() is provided for these cases.
- //
- abstract_value_type operator()( difference_type at ) const
- {
- BOOST_ASSERT( at >= 0 && at < size() );
- return m_Begin[at];
- }
-
- iterator_range& advance_begin( difference_type n )
- {
- BOOST_ASSERT( !is_singular() );
- std::advance( m_Begin, n );
- return *this;
- }
-
- iterator_range& advance_end( difference_type n )
- {
- BOOST_ASSERT( !is_singular() );
- std::advance( m_End, n );
- return *this;
- }
-
- private:
- // begin and end iterators
- IteratorT m_Begin;
- IteratorT m_End;
-
- #ifndef NDEBUG
- bool singular;
- #endif
-
- public:
- bool is_singular() const
- {
- #ifndef NDEBUG
- return singular;
- #else
- return false;
- #endif
- }
-
- protected:
- //
- // Allow subclasses an easy way to access the
- // base type
- //
- typedef iterator_range iterator_range_;
- };
-
-// iterator range free-standing operators ---------------------------//
-
-#ifndef _STLP_NO_IOSTREAMS
-# ifndef BOOST_OLD_IOSTREAMS
-
- //! iterator_range output operator
- /*!
- Output the range to an ostream. Elements are outputed
- in a sequence without separators.
- */
- template< typename IteratorT, typename Elem, typename Traits >
- inline std::basic_ostream<Elem,Traits>& operator<<(
- std::basic_ostream<Elem, Traits>& Os,
- const iterator_range<IteratorT>& r )
- {
- std::copy( r.begin(), r.end(),
- std::ostream_iterator< BOOST_DEDUCED_TYPENAME
- iterator_value<IteratorT>::type,
- Elem, Traits>(Os) );
- return Os;
- }
-
-# else
-
- //! iterator_range output operator
- /*!
- Output the range to an ostream. Elements are outputed
- in a sequence without separators.
- */
- template< typename IteratorT >
- inline std::ostream& operator<<(
- std::ostream& Os,
- const iterator_range<IteratorT>& r )
- {
- std::copy( r.begin(), r.end(), std::ostream_iterator<char>(Os));
- return Os;
- }
-
-# endif
-#endif // _STLP_NO_IOSTREAMS
-
- /////////////////////////////////////////////////////////////////////
- // comparison operators
- /////////////////////////////////////////////////////////////////////
-
- template< class IteratorT, class ForwardRange >
- inline bool operator==( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
- {
- return iterator_range_detail::equal( l, r );
- }
-
- template< class IteratorT, class ForwardRange >
- inline bool operator!=( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
- {
- return !iterator_range_detail::equal( l, r );
- }
-
- template< class IteratorT, class ForwardRange >
- inline bool operator<( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
- {
- return iterator_range_detail::less_than( l, r );
- }
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-#else
- template< class Iterator1T, class Iterator2T >
- inline bool operator==( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
- {
- return iterator_range_detail::equal( l, r );
- }
-
- template< class IteratorT, class ForwardRange >
- inline bool operator==( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
- {
- return iterator_range_detail::equal( l, r );
- }
-
-
- template< class Iterator1T, class Iterator2T >
- inline bool operator!=( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
- {
- return !iterator_range_detail::equal( l, r );
- }
-
- template< class IteratorT, class ForwardRange >
- inline bool operator!=( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
- {
- return !iterator_range_detail::equal( l, r );
- }
-
-
- template< class Iterator1T, class Iterator2T >
- inline bool operator<( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
- {
- return iterator_range_detail::less_than( l, r );
- }
-
- template< class IteratorT, class ForwardRange >
- inline bool operator<( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
- {
- return iterator_range_detail::less_than( l, r );
- }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-// iterator range utilities -----------------------------------------//
-
- //! iterator_range construct helper
- /*!
- Construct an \c iterator_range from a pair of iterators
-
- \param Begin A begin iterator
- \param End An end iterator
- \return iterator_range object
- */
- template< typename IteratorT >
- inline iterator_range< IteratorT >
- make_iterator_range( IteratorT Begin, IteratorT End )
- {
- return iterator_range<IteratorT>( Begin, End );
- }
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- template< typename Range >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
- make_iterator_range( Range& r )
- {
- return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
- ( boost::begin( r ), boost::end( r ) );
- }
-
-#else
- //! iterator_range construct helper
- /*!
- Construct an \c iterator_range from a \c Range containing the begin
- and end iterators.
- */
- template< class ForwardRange >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
- make_iterator_range( ForwardRange& r )
- {
- return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
- ( r, iterator_range_detail::range_tag() );
- }
-
- template< class ForwardRange >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
- make_iterator_range( const ForwardRange& r )
- {
- return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
- ( r, iterator_range_detail::const_range_tag() );
- }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- namespace iterator_range_detail
- {
- template< class Range >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
- make_range_impl( Range& r,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
- {
- //
- // Not worth the effort
- //
- //if( advance_begin == 0 && advance_end == 0 )
- // return make_iterator_range( r );
- //
-
- BOOST_DEDUCED_TYPENAME range_iterator<Range>::type
- new_begin = boost::begin( r ),
- new_end = boost::end( r );
- std::advance( new_begin, advance_begin );
- std::advance( new_end, advance_end );
- return make_iterator_range( new_begin, new_end );
- }
- }
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- template< class Range >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
- make_iterator_range( Range& r,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
- {
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
- return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
- }
-
-#else
-
- template< class Range >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
- make_iterator_range( Range& r,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
- {
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
- return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
- }
-
- template< class Range >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
- make_iterator_range( const Range& r,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
- BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
- {
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
- return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
- }
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- //! copy a range into a sequence
- /*!
- Construct a new sequence of the specified type from the elements
- in the given range
-
- \param Range An input range
- \return New sequence
- */
- template< typename SeqT, typename Range >
- inline SeqT copy_range( const Range& r )
- {
- return SeqT( boost::begin( r ), boost::end( r ) );
- }
-
-} // namespace 'boost'
-
-#undef BOOST_OLD_IOSTREAMS
-
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
- #pragma warning( pop )
-#endif
-
-#endif
+#include "boost/range/iterator_range_core.hpp"
+#include "boost/range/iterator_range_io.hpp"
+#endif // include guard
diff --git a/3rdParty/Boost/src/boost/range/iterator_range_core.hpp b/3rdParty/Boost/src/boost/range/iterator_range_core.hpp
new file mode 100755
index 0000000..497b1e3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/iterator_range_core.hpp
@@ -0,0 +1,542 @@
+// Boost.Range library
+//
+// Copyright Neil Groves & Thorsten Ottosen & Pavol Droba 2003-2004.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+
+#include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <iterator>
+#include <algorithm>
+#include <cstddef>
+
+/*! \file
+ Defines the \c iterator_class and related functions.
+ \c iterator_range is a simple wrapper of iterator pair idiom. It provides
+ a rich subset of Container interface.
+*/
+
+
+namespace boost
+{
+ namespace iterator_range_detail
+ {
+ //
+ // The functions adl_begin and adl_end are implemented in a separate
+ // class for gcc-2.9x
+ //
+ template<class IteratorT>
+ struct iterator_range_impl {
+ template< class ForwardRange >
+ static IteratorT adl_begin( ForwardRange& r )
+ {
+ return IteratorT( boost::begin( r ) );
+ }
+
+ template< class ForwardRange >
+ static IteratorT adl_end( ForwardRange& r )
+ {
+ return IteratorT( boost::end( r ) );
+ }
+ };
+
+ template< class Left, class Right >
+ inline bool less_than( const Left& l, const Right& r )
+ {
+ return std::lexicographical_compare( boost::begin(l),
+ boost::end(l),
+ boost::begin(r),
+ boost::end(r) );
+ }
+
+ // This version is maintained since it is used in other boost libraries
+ // such as Boost.Assign
+ template< class Left, class Right >
+ inline bool equal(const Left& l, const Right& r)
+ {
+ return boost::equal(l, r);
+ }
+
+ struct range_tag { };
+ struct const_range_tag { };
+
+ }
+
+// iterator range template class -----------------------------------------//
+
+ //! iterator_range class
+ /*!
+ An \c iterator_range delimits a range in a sequence by beginning and ending iterators.
+ An iterator_range can be passed to an algorithm which requires a sequence as an input.
+ For example, the \c toupper() function may be used most frequently on strings,
+ but can also be used on iterator_ranges:
+
+ \code
+ boost::tolower( find( s, "UPPERCASE STRING" ) );
+ \endcode
+
+ Many algorithms working with sequences take a pair of iterators,
+ delimiting a working range, as an arguments. The \c iterator_range class is an
+ encapsulation of a range identified by a pair of iterators.
+ It provides a collection interface,
+ so it is possible to pass an instance to an algorithm requiring a collection as an input.
+ */
+ template<class IteratorT>
+ class iterator_range
+ {
+ protected: // Used by sub_range
+ //! implementation class
+ typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
+ public:
+
+ //! this type
+ typedef iterator_range<IteratorT> type;
+ //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
+
+ //! Encapsulated value type
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_value<IteratorT>::type value_type;
+
+ //! Difference type
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_difference<IteratorT>::type difference_type;
+
+ //! Size type
+ typedef std::size_t size_type; // note: must be unsigned
+
+ //! This type
+ typedef iterator_range<IteratorT> this_type;
+
+ //! Reference type
+ //
+ // Needed because value-type is the same for
+ // const and non-const iterators
+ //
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_reference<IteratorT>::type reference;
+
+ //! const_iterator type
+ /*!
+ There is no distinction between const_iterator and iterator.
+ These typedefs are provides to fulfill container interface
+ */
+ typedef IteratorT const_iterator;
+ //! iterator type
+ typedef IteratorT iterator;
+
+ private: // for return value of operator()()
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_< boost::is_abstract<value_type>,
+ reference, value_type >::type abstract_value_type;
+
+ public:
+ iterator_range() : m_Begin( iterator() ), m_End( iterator() )
+ { }
+
+ //! Constructor from a pair of iterators
+ template< class Iterator >
+ iterator_range( Iterator Begin, Iterator End ) :
+ m_Begin(Begin), m_End(End)
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( const Range& r ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( Range& r ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( Range& r, iterator_range_detail::range_tag ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+ {}
+
+ #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ this_type& operator=( const this_type& r )
+ {
+ m_Begin = r.begin();
+ m_End = r.end();
+ return *this;
+ }
+ #endif
+
+ template< class Iterator >
+ iterator_range& operator=( const iterator_range<Iterator>& r )
+ {
+ m_Begin = r.begin();
+ m_End = r.end();
+ return *this;
+ }
+
+ template< class ForwardRange >
+ iterator_range& operator=( ForwardRange& r )
+ {
+ m_Begin = impl::adl_begin( r );
+ m_End = impl::adl_end( r );
+ return *this;
+ }
+
+ template< class ForwardRange >
+ iterator_range& operator=( const ForwardRange& r )
+ {
+ m_Begin = impl::adl_begin( r );
+ m_End = impl::adl_end( r );
+ return *this;
+ }
+
+ IteratorT begin() const
+ {
+ return m_Begin;
+ }
+
+ IteratorT end() const
+ {
+ return m_End;
+ }
+
+ difference_type size() const
+ {
+ return m_End - m_Begin;
+ }
+
+ bool empty() const
+ {
+ return m_Begin == m_End;
+ }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ operator bool() const
+ {
+ return !empty();
+ }
+#else
+ typedef iterator (iterator_range::*unspecified_bool_type) () const;
+ operator unspecified_bool_type() const
+ {
+ return empty() ? 0: &iterator_range::end;
+ }
+#endif
+
+ bool equal( const iterator_range& r ) const
+ {
+ return m_Begin == r.m_Begin && m_End == r.m_End;
+ }
+
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ bool operator==( const iterator_range& r ) const
+ {
+ return boost::equal( *this, r );
+ }
+
+ bool operator!=( const iterator_range& r ) const
+ {
+ return !operator==(r);
+ }
+
+ bool operator<( const iterator_range& r ) const
+ {
+ return iterator_range_detail::less_than( *this, r );
+ }
+
+#endif
+
+ public: // convenience
+ reference front() const
+ {
+ BOOST_ASSERT( !empty() );
+ return *m_Begin;
+ }
+
+ reference back() const
+ {
+ BOOST_ASSERT( !empty() );
+ IteratorT last( m_End );
+ return *--last;
+ }
+
+ reference operator[]( difference_type at ) const
+ {
+ BOOST_ASSERT( at >= 0 && at < size() );
+ return m_Begin[at];
+ }
+
+ //
+ // When storing transform iterators, operator[]()
+ // fails because it returns by reference. Therefore
+ // operator()() is provided for these cases.
+ //
+ abstract_value_type operator()( difference_type at ) const
+ {
+ BOOST_ASSERT( at >= 0 && at < size() );
+ return m_Begin[at];
+ }
+
+ iterator_range& advance_begin( difference_type n )
+ {
+ std::advance( m_Begin, n );
+ return *this;
+ }
+
+ iterator_range& advance_end( difference_type n )
+ {
+ std::advance( m_End, n );
+ return *this;
+ }
+
+ private:
+ // begin and end iterators
+ IteratorT m_Begin;
+ IteratorT m_End;
+
+ protected:
+ //
+ // Allow subclasses an easy way to access the
+ // base type
+ //
+ typedef iterator_range iterator_range_;
+ };
+
+// iterator range free-standing operators ---------------------------//
+
+ /////////////////////////////////////////////////////////////////////
+ // comparison operators
+ /////////////////////////////////////////////////////////////////////
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator==( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator!=( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#else
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator==( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator==( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return boost::equal( l, r );
+ }
+
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator!=( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator!=( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator<( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+// iterator range utilities -----------------------------------------//
+
+ //! iterator_range construct helper
+ /*!
+ Construct an \c iterator_range from a pair of iterators
+
+ \param Begin A begin iterator
+ \param End An end iterator
+ \return iterator_range object
+ */
+ template< typename IteratorT >
+ inline iterator_range< IteratorT >
+ make_iterator_range( IteratorT Begin, IteratorT End )
+ {
+ return iterator_range<IteratorT>( Begin, End );
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ ( boost::begin( r ), boost::end( r ) );
+ }
+
+#else
+ //! iterator_range construct helper
+ /*!
+ Construct an \c iterator_range from a \c Range containing the begin
+ and end iterators.
+ */
+ template< class ForwardRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+ make_iterator_range( ForwardRange& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+ ( r, iterator_range_detail::range_tag() );
+ }
+
+ template< class ForwardRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+ make_iterator_range( const ForwardRange& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+ ( r, iterator_range_detail::const_range_tag() );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ namespace iterator_range_detail
+ {
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_range_impl( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //
+ // Not worth the effort
+ //
+ //if( advance_begin == 0 && advance_end == 0 )
+ // return make_iterator_range( r );
+ //
+
+ BOOST_DEDUCED_TYPENAME range_iterator<Range>::type
+ new_begin = boost::begin( r ),
+ new_end = boost::end( r );
+ std::advance( new_begin, advance_begin );
+ std::advance( new_end, advance_end );
+ return make_iterator_range( new_begin, new_end );
+ }
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+#else
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
+ make_iterator_range( const Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! copy a range into a sequence
+ /*!
+ Construct a new sequence of the specified type from the elements
+ in the given range
+
+ \param Range An input range
+ \return New sequence
+ */
+ template< typename SeqT, typename Range >
+ inline SeqT copy_range( const Range& r )
+ {
+ return SeqT( boost::begin( r ), boost::end( r ) );
+ }
+
+} // namespace 'boost'
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( pop )
+#endif
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/range/iterator_range_io.hpp b/3rdParty/Boost/src/boost/range/iterator_range_io.hpp
new file mode 100755
index 0000000..51e3a4f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/iterator_range_io.hpp
@@ -0,0 +1,93 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
+// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
+#ifndef BOOST_OLD_IOSTREAMS
+# if defined(__STL_CONFIG_H) && \
+ !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
+ /**/
+# define BOOST_OLD_IOSTREAMS
+# endif
+#endif // #ifndef BOOST_OLD_IOSTREAMS
+
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS
+# include <ostream>
+# else
+# include <ostream.h>
+# endif
+#endif // _STLP_NO_IOSTREAMS
+
+#include <boost/range/iterator_range_core.hpp>
+#include <iterator>
+#include <algorithm>
+#include <cstddef>
+
+namespace boost
+{
+
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS
+
+ //! iterator_range output operator
+ /*!
+ Output the range to an ostream. Elements are outputed
+ in a sequence without separators.
+ */
+ template< typename IteratorT, typename Elem, typename Traits >
+ inline std::basic_ostream<Elem,Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& Os,
+ const iterator_range<IteratorT>& r )
+ {
+ std::copy( r.begin(), r.end(),
+ std::ostream_iterator< BOOST_DEDUCED_TYPENAME
+ iterator_value<IteratorT>::type,
+ Elem, Traits>(Os) );
+ return Os;
+ }
+
+# else
+
+ //! iterator_range output operator
+ /*!
+ Output the range to an ostream. Elements are outputed
+ in a sequence without separators.
+ */
+ template< typename IteratorT >
+ inline std::ostream& operator<<(
+ std::ostream& Os,
+ const iterator_range<IteratorT>& r )
+ {
+ std::copy( r.begin(), r.end(), std::ostream_iterator<char>(Os));
+ return Os;
+ }
+
+# endif
+#endif // _STLP_NO_IOSTREAMS
+
+} // namespace boost
+
+#undef BOOST_OLD_IOSTREAMS
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning(pop)
+#endif
+
+#endif // include guard
diff --git a/3rdParty/Boost/src/boost/range/mutable_iterator.hpp b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp
index 2f45c16..7beca66 100644
--- a/3rdParty/Boost/src/boost/range/mutable_iterator.hpp
+++ b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp
@@ -21,6 +21,7 @@
#include <boost/range/detail/iterator.hpp>
#else
+#include <boost/range/detail/extract_optional_type.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <cstddef>
#include <utility>
@@ -31,11 +32,13 @@ namespace boost
// default
//////////////////////////////////////////////////////////////////////////
+ namespace range_detail {
+ BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
+ }
+
template< typename C >
- struct range_mutable_iterator
- {
- typedef BOOST_DEDUCED_TYPENAME C::iterator type;
- };
+ struct range_mutable_iterator : range_detail::extract_iterator<C>
+ {};
//////////////////////////////////////////////////////////////////////////
// pair
diff --git a/3rdParty/Boost/src/boost/range/size.hpp b/3rdParty/Boost/src/boost/range/size.hpp
index 311a692..2b572d4 100644
--- a/3rdParty/Boost/src/boost/range/size.hpp
+++ b/3rdParty/Boost/src/boost/range/size.hpp
@@ -20,7 +20,7 @@
#include <boost/range/difference_type.hpp>
#include <boost/assert.hpp>
-namespace boost
+namespace boost
{
template< class T >
diff --git a/3rdParty/Boost/src/boost/range/size_type.hpp b/3rdParty/Boost/src/boost/range/size_type.hpp
index 7ed8dfa..8c184f8 100644
--- a/3rdParty/Boost/src/boost/range/size_type.hpp
+++ b/3rdParty/Boost/src/boost/range/size_type.hpp
@@ -67,7 +67,8 @@ namespace boost
{ };
template< class T >
- struct range_size<const T > : range_size<T>
+ struct range_size<const T >
+ : detail::range_size<T>
{ };
} // namespace boost