Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/range | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/range')
35 files changed, 1097 insertions, 844 deletions
diff --git a/3rdParty/Boost/src/boost/range/algorithm/equal.hpp b/3rdParty/Boost/src/boost/range/algorithm/equal.hpp index 4472bb1..2b44f3b 100644 --- a/3rdParty/Boost/src/boost/range/algorithm/equal.hpp +++ b/3rdParty/Boost/src/boost/range/algorithm/equal.hpp @@ -28,13 +28,13 @@ namespace boost SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, IteratorCategoryTag1, IteratorCategoryTag2 ) { - while (true) + for (;;) { // 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; @@ -68,13 +68,13 @@ namespace boost SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, BinaryPredicate pred, IteratorCategoryTag1, IteratorCategoryTag2 ) { - while (true) + for (;;) { // 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; @@ -117,13 +117,15 @@ namespace boost class RandomAccessTraversalReadableIterator2, class BinaryPredicate > inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1, RandomAccessTraversalReadableIterator1 last1, RandomAccessTraversalReadableIterator2 first2, RandomAccessTraversalReadableIterator2 last2, - BinaryPredicate pred ) + BinaryPredicate pred, + std::random_access_iterator_tag, + std::random_access_iterator_tag ) { return ((last1 - first1) == (last2 - first2)) && std::equal(first1, last1, first2, pred); } template< class SinglePassTraversalReadableIterator1, diff --git a/3rdParty/Boost/src/boost/range/as_literal.hpp b/3rdParty/Boost/src/boost/range/as_literal.hpp index 9ea144d..1c16e4a 100644 --- a/3rdParty/Boost/src/boost/range/as_literal.hpp +++ b/3rdParty/Boost/src/boost/range/as_literal.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_AS_LITERAL_HPP #define BOOST_RANGE_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING #include <boost/range/detail/as_literal.hpp> #else diff --git a/3rdParty/Boost/src/boost/range/begin.hpp b/3rdParty/Boost/src/boost/range/begin.hpp index c668488..ba5a73b 100644 --- a/3rdParty/Boost/src/boost/range/begin.hpp +++ b/3rdParty/Boost/src/boost/range/begin.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_BEGIN_HPP #define BOOST_RANGE_BEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING @@ -23,15 +23,13 @@ #include <boost/range/iterator.hpp> namespace boost { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) namespace range_detail { #endif ////////////////////////////////////////////////////////////////////// // primary template @@ -82,41 +80,35 @@ namespace range_detail inline T* range_begin( T (&a)[sz] ) { return a; } -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif // Use a ADL namespace barrier to avoid ambiguity with other unqualified // calls. This is particularly important with C++0x encouraging // unqualified calls to begin/end. namespace range_adl_barrier { template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_begin( r ); } template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_begin( r ); } } // namespace range_adl_barrier diff --git a/3rdParty/Boost/src/boost/range/concepts.hpp b/3rdParty/Boost/src/boost/range/concepts.hpp index 5965293..3e612a3 100644 --- a/3rdParty/Boost/src/boost/range/concepts.hpp +++ b/3rdParty/Boost/src/boost/range/concepts.hpp @@ -20,12 +20,13 @@ #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> +#include <boost/type_traits/remove_reference.hpp> /*! * \file * \brief Concept checks for the Boost Range library. * * The structures in this file may be used in conjunction with the @@ -60,21 +61,30 @@ namespace boost { namespace range_detail { #ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT // List broken compiler versions here: +#ifndef __clang__ #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 __GCCXML__ + // GCC XML, unsurprisingly, has the same issues + #if __GCCXML_GNUC__ == 4 && __GCCXML_GNUC_MINOR__ == 2 + #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0 + #endif + #endif +#endif + #ifdef __BORLANDC__ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0 #endif #ifdef __PATHCC__ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0 @@ -250,47 +260,57 @@ namespace boost { //! 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; + // A few compilers don't like the rvalue reference T types so just + // remove it. + typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type Rng; - BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>)); - BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>)); + typedef BOOST_DEDUCED_TYPENAME range_iterator< + Rng const + >::type const_iterator; - BOOST_CONCEPT_USAGE(SinglePassRangeConcept) - { + typedef BOOST_DEDUCED_TYPENAME range_iterator<Rng>::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); + boost::ignore_unused_variable_warning(i1); + boost::ignore_unused_variable_warning(i2); const_constraints(*m_range); } private: - void const_constraints(const T& const_range) + void const_constraints(const Rng& 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); + boost::ignore_unused_variable_warning(ci1); + boost::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; + Rng* m_range; #endif }; //! Check if a type T models the ForwardRange range concept. template<class T> struct ForwardRangeConcept : SinglePassRangeConcept<T> @@ -298,25 +318,25 @@ namespace boost { #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> + template<class T> struct WriteableRangeConcept { #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT - typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator; + typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator; BOOST_CONCEPT_USAGE(WriteableRangeConcept) { *i = v; } private: iterator i; - BOOST_DEDUCED_TYPENAME range_value<Range>::type v; + BOOST_DEDUCED_TYPENAME range_value<T>::type v; #endif }; //! Check if a type T models the WriteableForwardRange range concept. template<class T> struct WriteableForwardRangeConcept @@ -327,14 +347,14 @@ namespace boost { //! 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>)); + BOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>)); + BOOST_RANGE_CONCEPT_ASSERT((range_detail::BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>)); #endif }; //! Check if a type T models the WriteableBidirectionalRange range concept. template<class T> struct WriteableBidirectionalRangeConcept @@ -345,14 +365,14 @@ namespace boost { //! 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>)); + BOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>)); + BOOST_RANGE_CONCEPT_ASSERT((range_detail::RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>)); #endif }; //! Check if a type T models the WriteableRandomAccessRange range concept. template<class T> struct WriteableRandomAccessRangeConcept diff --git a/3rdParty/Boost/src/boost/range/config.hpp b/3rdParty/Boost/src/boost/range/config.hpp index 4e7fb24..7600a5f 100644 --- a/3rdParty/Boost/src/boost/range/config.hpp +++ b/3rdParty/Boost/src/boost/range/config.hpp @@ -10,45 +10,47 @@ #ifndef BOOST_RANGE_CONFIG_HPP #define BOOST_RANGE_CONFIG_HPP #include <boost/detail/workaround.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/config.hpp> #ifdef BOOST_RANGE_DEDUCED_TYPENAME #error "macro already defined!" #endif #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) # define BOOST_RANGE_DEDUCED_TYPENAME typename #else -# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS) -# define BOOST_RANGE_DEDUCED_TYPENAME typename -# else -# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME -# endif +#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME #endif #ifdef BOOST_RANGE_NO_ARRAY_SUPPORT #error "macro already defined!" #endif -#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) #define BOOST_RANGE_NO_ARRAY_SUPPORT 1 #endif #ifdef BOOST_RANGE_NO_ARRAY_SUPPORT #define BOOST_RANGE_ARRAY_REF() (boost_range_array) #define BOOST_RANGE_NO_STATIC_ASSERT #else #define BOOST_RANGE_ARRAY_REF() (&boost_range_array) #endif +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) +# define BOOST_RANGE_UNUSED __attribute__((unused)) +#else +# define BOOST_RANGE_UNUSED +#endif + #endif diff --git a/3rdParty/Boost/src/boost/range/const_iterator.hpp b/3rdParty/Boost/src/boost/range/const_iterator.hpp index 875320f..3413e59 100644 --- a/3rdParty/Boost/src/boost/range/const_iterator.hpp +++ b/3rdParty/Boost/src/boost/range/const_iterator.hpp @@ -8,60 +8,69 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_CONST_ITERATOR_HPP #define BOOST_RANGE_CONST_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include <boost/range/detail/const_iterator.hpp> -#else - +#include <boost/range/range_fwd.hpp> #include <boost/range/detail/extract_optional_type.hpp> #include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> #include <cstddef> #include <utility> namespace boost { ////////////////////////////////////////////////////////////////////////// // default ////////////////////////////////////////////////////////////////////////// - namespace range_detail { - BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator ) - } + namespace range_detail + { - template< typename C > - struct range_const_iterator : range_detail::extract_const_iterator<C> - {}; - - ////////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////////// +BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator ) - template< typename Iterator > - struct range_const_iterator< std::pair<Iterator,Iterator> > - { - typedef Iterator type; - }; - - ////////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////////// +template< typename C > +struct range_const_iterator + : extract_const_iterator<C> +{}; - template< typename T, std::size_t sz > - struct range_const_iterator< T[sz] > - { - typedef const T* type; - }; +////////////////////////////////////////////////////////////////////////// +// pair +////////////////////////////////////////////////////////////////////////// + +template< typename Iterator > +struct range_const_iterator<std::pair<Iterator,Iterator> > +{ + typedef Iterator type; +}; + +////////////////////////////////////////////////////////////////////////// +// array +////////////////////////////////////////////////////////////////////////// + +template< typename T, std::size_t sz > +struct range_const_iterator< T[sz] > +{ + typedef const T* type; +}; + + } // namespace range_detail + +template<typename C, typename Enabler=void> +struct range_const_iterator + : range_detail::range_const_iterator< + BOOST_DEDUCED_TYPENAME remove_reference<C>::type + > +{ +}; } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif diff --git a/3rdParty/Boost/src/boost/range/detail/as_literal.hpp b/3rdParty/Boost/src/boost/range/detail/as_literal.hpp index 0bd9a15..8b219ea 100644 --- a/3rdParty/Boost/src/boost/range/detail/as_literal.hpp +++ b/3rdParty/Boost/src/boost/range/detail/as_literal.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP #define BOOST_RANGE_DETAIL_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/detail/detail_str.hpp> #include <boost/range/iterator_range.hpp> diff --git a/3rdParty/Boost/src/boost/range/detail/begin.hpp b/3rdParty/Boost/src/boost/range/detail/begin.hpp index f3da732..1d9390f 100644 --- a/3rdParty/Boost/src/boost/range/detail/begin.hpp +++ b/3rdParty/Boost/src/boost/range/detail/begin.hpp @@ -12,15 +12,12 @@ #define BOOST_RANGE_DETAIL_BEGIN_HPP #include <boost/config.hpp> // BOOST_MSVC #include <boost/detail/workaround.hpp> #include <boost/range/iterator.hpp> #include <boost/range/detail/common.hpp> -#if BOOST_WORKAROUND(BOOST_MSVC, < 1310) -# include <boost/range/value_type.hpp> -#endif namespace boost { namespace range_detail { @@ -59,25 +56,17 @@ namespace boost // array ////////////////////////////////////////////////////////////////////// template<> struct range_begin<array_> { - #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) - template< typename T, std::size_t sz > - static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost_range_array; - } - #else template<typename T> static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t) { return t; } - #endif }; } // namespace 'range_detail' namespace range_adl_barrier { diff --git a/3rdParty/Boost/src/boost/range/detail/common.hpp b/3rdParty/Boost/src/boost/range/detail/common.hpp index f7539f5..b0ad535 100644 --- a/3rdParty/Boost/src/boost/range/detail/common.hpp +++ b/3rdParty/Boost/src/boost/range/detail/common.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_DETAIL_COMMON_HPP #define BOOST_RANGE_DETAIL_COMMON_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/detail/sfinae.hpp> #include <boost/type_traits/is_void.hpp> diff --git a/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp b/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp deleted file mode 100644 index e5cb34a..0000000 --- a/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp +++ /dev/null @@ -1,71 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 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_DETAIL_CONST_ITERATOR_HPP -#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP - -#include <boost/range/detail/common.hpp> -#include <boost/range/detail/remove_extent.hpp> - -////////////////////////////////////////////////////////////////////////////// -// missing partial specialization workaround. -////////////////////////////////////////////////////////////////////////////// - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_const_iterator_; - - template<> - struct range_const_iterator_<std_container_> - { - template< typename C > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type; - }; - }; - - template<> - struct range_const_iterator_<std_pair_> - { - template< typename P > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; - }; - }; - - - template<> - struct range_const_iterator_<array_> - { - template< typename T > - struct pts - { - typedef const BOOST_RANGE_DEDUCED_TYPENAME - remove_extent<T>::type* type; - }; - }; - } - - template< typename C > - class range_const_iterator - { - typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type; - public: - typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; - }; - -} - -#endif diff --git a/3rdParty/Boost/src/boost/range/detail/end.hpp b/3rdParty/Boost/src/boost/range/detail/end.hpp index 8b5f35d..f2f7178 100644 --- a/3rdParty/Boost/src/boost/range/detail/end.hpp +++ b/3rdParty/Boost/src/boost/range/detail/end.hpp @@ -11,21 +11,15 @@ #ifndef BOOST_RANGE_DETAIL_END_HPP #define BOOST_RANGE_DETAIL_END_HPP #include <boost/config.hpp> // BOOST_MSVC #include <boost/detail/workaround.hpp> -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -# include <boost/range/detail/vc6/end.hpp> -#else -# include <boost/range/detail/implementation_help.hpp> -# include <boost/range/iterator.hpp> -# include <boost/range/detail/common.hpp> -# if BOOST_WORKAROUND(BOOST_MSVC, < 1310) -# include <boost/range/detail/remove_extent.hpp> -# endif +#include <boost/range/detail/implementation_help.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/detail/common.hpp> namespace boost { namespace range_detail { template< typename T > @@ -65,25 +59,17 @@ namespace boost // array ////////////////////////////////////////////////////////////////////// template<> struct range_end<array_> { - #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) - template< typename T, std::size_t sz > - static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] ) - { - return boost::range_detail::array_end( boost_range_array ); - } - #else template<typename T> static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t) { return t + remove_extent<T>::size; } - #endif }; } // namespace 'range_detail' namespace range_adl_barrier { @@ -94,8 +80,7 @@ namespace boost return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c ); } } // namespace range_adl_barrier } // namespace 'boost' -# endif // VC6 #endif diff --git a/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp b/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp index 8292e34..0381434 100644 --- a/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp +++ b/3rdParty/Boost/src/boost/range/detail/extract_optional_type.hpp @@ -7,46 +7,42 @@ // // 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) +#if defined(_MSC_VER) # pragma once #endif #include <boost/config.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/mpl/has_xxx.hpp> -#ifdef BOOST_NO_PARTIAL_TEMPLATE_SPECIALIZATION +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) -#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ - template< typename C > \ - struct extract_ ## a_typedef \ - { \ - typedef BOOST_DEDUCED_TYPENAME C::a_typedef 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 ) \ + BOOST_MPL_HAS_XXX_TRAIT_DEF(a_typedef) \ + template< typename C, bool B = BOOST_PP_CAT(has_, a_typedef)<C>::value > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + {}; \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef)< C, true > \ + { \ + 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; \ +#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + { \ + typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \ }; #endif #endif // include guard diff --git a/3rdParty/Boost/src/boost/range/detail/has_member_size.hpp b/3rdParty/Boost/src/boost/range/detail/has_member_size.hpp new file mode 100644 index 0000000..0c639aa --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/has_member_size.hpp @@ -0,0 +1,66 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. +// +// 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_DETAIL_HAS_MEMBER_SIZE_HPP +#define BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP + +#include <boost/type_traits/is_class.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/cstdint.hpp> + +namespace boost +{ + namespace range_detail + { + +template<class T> +class has_member_size_impl +{ +private: + template<class U, U> + class check + { + }; + + template<class C> + static boost::uint8_t f(check<std::size_t(C::*)(void) const, &C::size>*); + + template<class C> + static boost::uint16_t f(...); + +public: + static const bool value = + (sizeof(f<T>(0)) == sizeof(boost::uint8_t)); + + typedef typename mpl::if_c< + (sizeof(f<T>(0)) == sizeof(boost::uint8_t)), + mpl::true_, + mpl::false_ + >::type type; +}; + +template<class T> +struct has_member_size +{ + typedef typename mpl::and_< + typename is_class<T>::type, + typename has_member_size_impl<const T>::type + >::type type; + + static const bool value = + is_class<T>::value && has_member_size_impl<const T>::value; +}; + + } // namespace range_detail +}// namespace boost + +#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 1f7d163..f35953f 100644 --- a/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp +++ b/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp @@ -92,12 +92,23 @@ namespace boost inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] ) { boost_range_silence_warning( boost_range_array ); return sz; } + inline bool is_same_address(const void* l, const void* r) + { + return l == r; + } + + template<class T1, class T2> + inline bool is_same_object(const T1& l, const T2& r) + { + return range_detail::is_same_address(&l, &r); + } + } // namespace 'range_detail' } // namespace 'boost' #endif diff --git a/3rdParty/Boost/src/boost/range/detail/iterator.hpp b/3rdParty/Boost/src/boost/range/detail/iterator.hpp deleted file mode 100644 index 58346d4..0000000 --- a/3rdParty/Boost/src/boost/range/detail/iterator.hpp +++ /dev/null @@ -1,78 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 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_DETAIL_ITERATOR_HPP -#define BOOST_RANGE_DETAIL_ITERATOR_HPP - -#include <boost/range/detail/common.hpp> -#include <boost/range/detail/remove_extent.hpp> - -#include <boost/static_assert.hpp> - -////////////////////////////////////////////////////////////////////////////// -// missing partial specialization workaround. -////////////////////////////////////////////////////////////////////////////// - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_iterator_ { - template< typename C > - struct pts - { - typedef int type; - }; - }; - - template<> - struct range_iterator_<std_container_> - { - template< typename C > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type; - }; - }; - - template<> - struct range_iterator_<std_pair_> - { - template< typename P > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; - }; - }; - - template<> - struct range_iterator_<array_> - { - template< typename T > - struct pts - { - typedef BOOST_RANGE_DEDUCED_TYPENAME - remove_extent<T>::type* type; - }; - }; - - } - - template< typename C > - class range_mutable_iterator - { - typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type; - public: - typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; - }; -} - -#endif diff --git a/3rdParty/Boost/src/boost/range/detail/msvc_has_iterator_workaround.hpp b/3rdParty/Boost/src/boost/range/detail/msvc_has_iterator_workaround.hpp new file mode 100644 index 0000000..62b67fd --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/msvc_has_iterator_workaround.hpp @@ -0,0 +1,132 @@ +// Boost.Range library +// +// Copyright Eric Niebler 2014. 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_MSVC_HAS_ITERATOR_WORKAROUND_HPP +#define BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP +# error This file should only be included from <boost/range/mutable_iterator.hpp> +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) +namespace boost +{ +namespace cb_details +{ + template <class Buff, class Traits> + struct iterator; +} + +namespace python +{ + template <class Container + , class NextPolicies /*= objects::default_iterator_call_policies*/> + struct iterator; +} + +namespace type_erasure +{ + template< + class Traversal, + class T /*= _self*/, + class Reference /*= ::boost::use_default*/, + class DifferenceType /*= ::std::ptrdiff_t*/, + class ValueType /*= typename deduced<iterator_value_type<T> >::type*/ + > + struct iterator; +} + +namespace unordered { namespace iterator_detail +{ + template <typename Node> + struct iterator; +}} + +namespace container { namespace container_detail +{ + template<class IIterator, bool IsConst> + class iterator; +}} + +namespace spirit { namespace lex { namespace lexertl +{ + template <typename Functor> + class iterator; +}}} + +namespace range_detail +{ + template <class Buff, class Traits> + struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> > + : mpl::false_ + {}; + + template <class Buff, class Traits> + struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> const> + : mpl::false_ + {}; + + template <class Container, class NextPolicies> + struct has_iterator< ::boost::python::iterator<Container, NextPolicies> > + : mpl::false_ + {}; + + template <class Container, class NextPolicies> + struct has_iterator< ::boost::python::iterator<Container, NextPolicies> const> + : mpl::false_ + {}; + + template<class Traversal, class T, class Reference, class DifferenceType, class ValueType> + struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> > + : mpl::false_ + {}; + + template<class Traversal, class T, class Reference, class DifferenceType, class ValueType> + struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> const> + : mpl::false_ + {}; + + template <typename Node> + struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> > + : mpl::false_ + {}; + + template <typename Node> + struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> const> + : mpl::false_ + {}; + + template<class IIterator, bool IsConst> + struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> > + : mpl::false_ + {}; + + template<class IIterator, bool IsConst> + struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> const> + : mpl::false_ + {}; + + template <typename Functor> + struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> > + : mpl::false_ + {}; + + template <typename Functor> + struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> const> + : mpl::false_ + {}; +} +} +#endif +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp b/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp deleted file mode 100644 index 4f76af5..0000000 --- a/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp +++ /dev/null @@ -1,170 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 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_DETAIL_VC6_END_HPP -#define BOOST_RANGE_DETAIL_VC6_END_HPP - -#include <boost/range/detail/implementation_help.hpp> -#include <boost/range/detail/implementation_help.hpp> -#include <boost/range/result_iterator.hpp> -#include <boost/range/detail/common.hpp> -#include <boost/range/detail/remove_extent.hpp> - -namespace boost -{ - namespace range_detail - { - template< typename T > - struct range_end; - - ////////////////////////////////////////////////////////////////////// - // default - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end<std_container_> - { - template< typename C > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type - fun( C& c ) - { - return c.end(); - }; - }; - }; - - ////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end<std_pair_> - { - template< typename P > - struct inner { - static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type - fun( const P& p ) - { - return p.second; - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end<array_> - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* - fun(T& t) - { - return t + remove_extent<T>::size; - } - }; - }; - - - template<> - struct range_end<char_array_> - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* - fun(T& t) - { - return t + remove_extent<T>::size; - } - }; - }; - - template<> - struct range_end<wchar_t_array_> - { - template< typename T > - struct inner { - static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* - fun(T& t) - { - return t + remove_extent<T>::size; - } - }; - }; - - ////////////////////////////////////////////////////////////////////// - // string - ////////////////////////////////////////////////////////////////////// - - template<> - struct range_end<char_ptr_> - { - template< typename T > - struct inner { - static char* fun( char* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - template<> - struct range_end<const_char_ptr_> - { - template< typename T > - struct inner { - static const char* fun( const char* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - template<> - struct range_end<wchar_t_ptr_> - { - template< typename T > - struct inner { - static wchar_t* fun( wchar_t* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - - template<> - struct range_end<const_wchar_t_ptr_> - { - template< typename T > - struct inner { - static const wchar_t* fun( const wchar_t* s ) - { - return boost::range_detail::str_end( s ); - } - }; - }; - - } // namespace 'range_detail' - - template< typename C > - inline BOOST_DEDUCED_TYPENAME range_result_iterator<C>::type - end( C& c ) - { - return range_detail::range_end<range_detail::range<C>::type>::inner<C>::fun( c ); - } - -} // namespace 'boost' - - -#endif diff --git a/3rdParty/Boost/src/boost/range/difference_type.hpp b/3rdParty/Boost/src/boost/range/difference_type.hpp index 164288f..afd8b07 100644 --- a/3rdParty/Boost/src/boost/range/difference_type.hpp +++ b/3rdParty/Boost/src/boost/range/difference_type.hpp @@ -8,22 +8,28 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP #define BOOST_RANGE_DIFFERENCE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/iterator.hpp> #include <boost/iterator/iterator_traits.hpp> +#include <boost/type_traits/remove_reference.hpp> namespace boost { template< class T > - struct range_difference : iterator_difference< typename range_iterator<T>::type > + struct range_difference + : iterator_difference< + BOOST_DEDUCED_TYPENAME range_iterator< + BOOST_DEDUCED_TYPENAME remove_reference<T>::type + >::type + > { }; } #endif diff --git a/3rdParty/Boost/src/boost/range/distance.hpp b/3rdParty/Boost/src/boost/range/distance.hpp index 42a106d..075f2d1 100644 --- a/3rdParty/Boost/src/boost/range/distance.hpp +++ b/3rdParty/Boost/src/boost/range/distance.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_DISTANCE_HPP #define BOOST_RANGE_DISTANCE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/difference_type.hpp> diff --git a/3rdParty/Boost/src/boost/range/empty.hpp b/3rdParty/Boost/src/boost/range/empty.hpp index 78c4e85..d57a30e 100644 --- a/3rdParty/Boost/src/boost/range/empty.hpp +++ b/3rdParty/Boost/src/boost/range/empty.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_EMPTY_HPP #define BOOST_RANGE_EMPTY_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> @@ -25,10 +25,10 @@ namespace boost template< class T > inline bool empty( const T& r ) { return boost::begin( r ) == boost::end( r ); } -} // namepace 'boost' +} // namespace 'boost' #endif diff --git a/3rdParty/Boost/src/boost/range/end.hpp b/3rdParty/Boost/src/boost/range/end.hpp index d5e6526..f2a3337 100644 --- a/3rdParty/Boost/src/boost/range/end.hpp +++ b/3rdParty/Boost/src/boost/range/end.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_END_HPP #define BOOST_RANGE_END_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING @@ -25,15 +25,13 @@ #include <boost/range/iterator.hpp> #include <boost/range/const_iterator.hpp> namespace boost { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) namespace range_detail { #endif ////////////////////////////////////////////////////////////////////// // primary template @@ -79,38 +77,32 @@ namespace range_detail template< typename T, std::size_t sz > inline T* range_end( T (&a)[sz] ) { return range_detail::array_end<T,sz>( a ); } -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif namespace range_adl_barrier { template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_end( r ); } template< class T > inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r ) { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) using namespace range_detail; #endif return range_end( r ); } } // namespace range_adl_barrier diff --git a/3rdParty/Boost/src/boost/range/functions.hpp b/3rdParty/Boost/src/boost/range/functions.hpp index b8b8608..43c54b1 100644 --- a/3rdParty/Boost/src/boost/range/functions.hpp +++ b/3rdParty/Boost/src/boost/range/functions.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_FUNCTIONS_HPP #define BOOST_RANGE_FUNCTIONS_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/size.hpp> diff --git a/3rdParty/Boost/src/boost/range/has_range_iterator.hpp b/3rdParty/Boost/src/boost/range/has_range_iterator.hpp new file mode 100644 index 0000000..9eb58b3 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/has_range_iterator.hpp @@ -0,0 +1,83 @@ +// Boost.Range library +// +// Copyright Neil Groves 2010. 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/ +// +// Acknowledgments: +// Ticket #8341: Arno Schoedl - improved handling of has_range_iterator upon +// use-cases where T was const. +#ifndef BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED +#define BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED + +#include <boost/mpl/bool.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/has_xxx.hpp> +#include <boost/range/iterator.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/utility/enable_if.hpp> + +namespace boost +{ + namespace range_detail + { + BOOST_MPL_HAS_XXX_TRAIT_DEF(type) + + template<class T, class Enabler = void> + struct has_range_iterator_impl + : boost::mpl::false_ + { + }; + + template<class T> + struct has_range_iterator_impl< + T, + BOOST_DEDUCED_TYPENAME ::boost::enable_if< + BOOST_DEDUCED_TYPENAME mpl::eval_if<is_const<T>, + has_type<range_const_iterator< + BOOST_DEDUCED_TYPENAME remove_const<T>::type> >, + has_type<range_mutable_iterator<T> > + >::type + >::type + > + : boost::mpl::true_ + { + }; + + template<class T, class Enabler = void> + struct has_range_const_iterator_impl + : boost::mpl::false_ + { + }; + + template<class T> + struct has_range_const_iterator_impl< + T, + BOOST_DEDUCED_TYPENAME ::boost::enable_if< + has_type<range_const_iterator<T> > + >::type + > + : boost::mpl::true_ + { + }; + + } // namespace range_detail + + template<class T> + struct has_range_iterator + : range_detail::has_range_iterator_impl< + BOOST_DEDUCED_TYPENAME remove_reference<T>::type> + {}; + + template<class T> + struct has_range_const_iterator + : range_detail::has_range_const_iterator_impl< + BOOST_DEDUCED_TYPENAME remove_reference<T>::type> + {}; +} // namespace boost + +#endif // include guard + diff --git a/3rdParty/Boost/src/boost/range/iterator.hpp b/3rdParty/Boost/src/boost/range/iterator.hpp index ec73ddc..f15bf3b 100644 --- a/3rdParty/Boost/src/boost/range/iterator.hpp +++ b/3rdParty/Boost/src/boost/range/iterator.hpp @@ -8,65 +8,69 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_ITERATOR_HPP #define BOOST_RANGE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> +#include <boost/range/range_fwd.hpp> #include <boost/range/mutable_iterator.hpp> #include <boost/range/const_iterator.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/mpl/eval_if.hpp> 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 - - template< typename C > +#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, typename Enabler=void > 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, - range_const_iterator< typename remove_const<C>::type >, - range_mutable_iterator<C> >::type type; - -#endif + + typedef BOOST_RANGE_DEDUCED_TYPENAME + range_detail_vc7_1::range_iterator<C>::type type; + +#else + + private: + typedef typename remove_reference<C>::type param_t; + + public: + typedef typename mpl::eval_if_c< + is_const<param_t>::value, + range_const_iterator<typename remove_const<param_t>::type>, + range_mutable_iterator<param_t> + >::type type; + +#endif }; - + } // namespace boost -//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - #endif diff --git a/3rdParty/Boost/src/boost/range/iterator_range_core.hpp b/3rdParty/Boost/src/boost/range/iterator_range_core.hpp index 60c7670..8108947 100644 --- a/3rdParty/Boost/src/boost/range/iterator_range_core.hpp +++ b/3rdParty/Boost/src/boost/range/iterator_range_core.hpp @@ -4,12 +4,16 @@ // 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/ // +// Credits: +// 'michel' reported Trac 9072 which included a patch for allowing references +// to function types. +// #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> @@ -18,17 +22,26 @@ #pragma warning( disable : 4996 ) #endif #include <boost/assert.hpp> #include <boost/iterator/iterator_traits.hpp> #include <boost/iterator/iterator_facade.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/or.hpp> #include <boost/type_traits/is_abstract.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_function.hpp> #include <boost/type_traits/is_pointer.hpp> +#include <boost/type_traits/is_same.hpp> #include <boost/range/functions.hpp> #include <boost/range/iterator.hpp> #include <boost/range/difference_type.hpp> +#include <boost/range/has_range_iterator.hpp> #include <boost/range/algorithm/equal.hpp> #include <boost/range/detail/safe_bool.hpp> #include <boost/utility/enable_if.hpp> #include <iterator> #include <algorithm> #include <cstddef> @@ -72,13 +85,13 @@ namespace boost boost::end(r) ); } template< class Left, class Right > inline bool greater_than( const Left& l, const Right& r ) { - return less_than(r,l); + return iterator_range_detail::less_than(r,l); } template< class Left, class Right > inline bool less_or_equal_than( const Left& l, const Right& r ) { return !iterator_range_detail::less_than(r,l); @@ -95,14 +108,309 @@ namespace boost 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 { }; +struct range_tag +{ +}; + +struct const_range_tag +{ +}; + +struct iterator_range_tag +{ +}; + +typedef char (&incrementable_t)[1]; +typedef char (&bidirectional_t)[2]; +typedef char (&random_access_t)[3]; + +incrementable_t test_traversal_tag(boost::incrementable_traversal_tag); +bidirectional_t test_traversal_tag(boost::bidirectional_traversal_tag); +random_access_t test_traversal_tag(boost::random_access_traversal_tag); + +template<std::size_t S> +struct pure_iterator_traversal_impl +{ + typedef boost::incrementable_traversal_tag type; +}; + +template<> +struct pure_iterator_traversal_impl<sizeof(bidirectional_t)> +{ + typedef boost::bidirectional_traversal_tag type; +}; + +template<> +struct pure_iterator_traversal_impl<sizeof(random_access_t)> +{ + typedef boost::random_access_traversal_tag type; +}; + +template<typename IteratorT> +struct pure_iterator_traversal +{ + typedef + BOOST_DEDUCED_TYPENAME iterator_traversal<IteratorT>::type + traversal_t; + BOOST_STATIC_CONSTANT( + std::size_t, + traversal_i = sizeof(iterator_range_detail::test_traversal_tag((traversal_t()))) + ); + typedef + BOOST_DEDUCED_TYPENAME pure_iterator_traversal_impl<traversal_i>::type + type; +}; + +template<class IteratorT, class TraversalTag> +class iterator_range_base + : public iterator_range_tag +{ + typedef range_detail::safe_bool< + IteratorT iterator_range_base<IteratorT, TraversalTag>::* + > safe_bool_t; + + typedef iterator_range_base<IteratorT, TraversalTag> type; + +protected: + typedef iterator_range_impl<IteratorT> impl; + +public: + typedef BOOST_DEDUCED_TYPENAME + safe_bool_t::unspecified_bool_type unspecified_bool_type; + + typedef BOOST_DEDUCED_TYPENAME + iterator_value<IteratorT>::type value_type; + + typedef BOOST_DEDUCED_TYPENAME + iterator_difference<IteratorT>::type difference_type; + + typedef std::size_t size_type; // note: must be unsigned + + // 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; + +protected: + iterator_range_base() + : m_Begin() + , m_End() + { + } + + template<class Iterator> + iterator_range_base(Iterator Begin, Iterator End) + : m_Begin(Begin) + , m_End(End) + { + } + +public: + IteratorT begin() const + { + return m_Begin; + } + + IteratorT end() const + { + return m_End; + } + + bool empty() const + { + return m_Begin == m_End; + } + + operator unspecified_bool_type() const + { + return safe_bool_t::to_unspecified_bool( + m_Begin != m_End, &iterator_range_base::m_Begin); + } + + bool operator!() const + { + return empty(); + } + + bool equal(const iterator_range_base& r) const + { + return m_Begin == r.m_Begin && m_End == r.m_End; + } + + reference front() const + { + BOOST_ASSERT(!empty()); + return *m_Begin; + } + + void drop_front() + { + BOOST_ASSERT(!empty()); + ++m_Begin; + } + + void drop_front(difference_type n) + { + BOOST_ASSERT(n >= difference_type()); + std::advance(this->m_Begin, n); + } + + // Deprecated + void pop_front() { drop_front(); } + +protected: + template<class Iterator> + void assign(Iterator first, Iterator last) + { + m_Begin = first; + m_End = last; + } + + template<class SinglePassRange> + void assign(const SinglePassRange& r) + { + m_Begin = impl::adl_begin(r); + m_End = impl::adl_end(r); + } + + template<class SinglePassRange> + void assign(SinglePassRange& r) + { + m_Begin = impl::adl_begin(r); + m_End = impl::adl_end(r); + } + + IteratorT m_Begin; + IteratorT m_End; +}; + +template<class IteratorT> +class iterator_range_base<IteratorT, bidirectional_traversal_tag> + : public iterator_range_base<IteratorT, incrementable_traversal_tag> +{ + typedef iterator_range_base<IteratorT, incrementable_traversal_tag> base_type; + +protected: + iterator_range_base() + { + } + + template<class Iterator> + iterator_range_base(Iterator first, Iterator last) + : base_type(first, last) + { + } + +public: + typedef BOOST_DEDUCED_TYPENAME base_type::difference_type difference_type; + typedef BOOST_DEDUCED_TYPENAME base_type::reference reference; + + reference back() const + { + BOOST_ASSERT(!this->empty()); + return *boost::prior(this->m_End); + } + + void drop_back() + { + BOOST_ASSERT(!this->empty()); + --this->m_End; + } + + void drop_back(difference_type n) + { + BOOST_ASSERT(n >= difference_type()); + std::advance(this->m_End, -n); + } + + // Deprecated + void pop_back() { drop_back(); } +}; + +template<class IteratorT> +class iterator_range_base<IteratorT, random_access_traversal_tag> + : public iterator_range_base<IteratorT, bidirectional_traversal_tag> +{ + typedef iterator_range_base< + IteratorT, bidirectional_traversal_tag> base_type; + +public: + typedef BOOST_DEDUCED_TYPENAME + boost::mpl::if_< + boost::mpl::or_< + boost::is_abstract< + BOOST_DEDUCED_TYPENAME base_type::value_type + >, + boost::is_array< + BOOST_DEDUCED_TYPENAME base_type::value_type + >, + boost::is_function< + BOOST_DEDUCED_TYPENAME base_type::value_type + > + >, + BOOST_DEDUCED_TYPENAME base_type::reference, + BOOST_DEDUCED_TYPENAME base_type::value_type + >::type abstract_value_type; + + // Rationale: + // typedef these here to reduce verbiage in the implementation of this + // type. + typedef BOOST_DEDUCED_TYPENAME base_type::difference_type difference_type; + typedef BOOST_DEDUCED_TYPENAME base_type::size_type size_type; + typedef BOOST_DEDUCED_TYPENAME base_type::reference reference; + +protected: + iterator_range_base() + { + } + + template<class Iterator> + iterator_range_base(Iterator first, Iterator last) + : base_type(first, last) + { + } + +public: + reference operator[](difference_type at) const + { + BOOST_ASSERT(at >= 0); + BOOST_ASSERT(static_cast<typename base_type::size_type>(at) < size()); + return this->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); + BOOST_ASSERT(static_cast<typename base_type::size_type>(at) < size()); + return this->m_Begin[at]; + } + + BOOST_DEDUCED_TYPENAME base_type::size_type size() const + { + return this->m_End - this->m_Begin; + } +}; + } // iterator range template class -----------------------------------------// //! iterator_range class /*! @@ -120,258 +428,129 @@ namespace boost 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 - { - typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t; - protected: // Used by sub_range - //! implementation class - typedef iterator_range_detail::iterator_range_impl<IteratorT> impl; - public: - //! this type - typedef iterator_range<IteratorT> type; - typedef BOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_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; + : public iterator_range_detail::iterator_range_base< + IteratorT, + BOOST_DEDUCED_TYPENAME iterator_range_detail::pure_iterator_traversal<IteratorT>::type + > + { + typedef iterator_range_detail::iterator_range_base< + IteratorT, + BOOST_DEDUCED_TYPENAME iterator_range_detail::pure_iterator_traversal<IteratorT>::type + > base_type; + + template<class Source> + struct is_compatible_range + : is_convertible< + BOOST_DEDUCED_TYPENAME mpl::eval_if< + has_range_iterator<Source>, + range_iterator<Source>, + mpl::identity<void> + >::type, + BOOST_DEDUCED_TYPENAME base_type::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; + protected: + typedef iterator_range_detail::iterator_range_impl<IteratorT> impl; 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 + typedef iterator_range<IteratorT> type; - template< class Iterator > - iterator_range& operator=( const iterator_range<Iterator>& r ) + iterator_range() { - m_Begin = r.begin(); - m_End = r.end(); - return *this; } - template< class ForwardRange > - iterator_range& operator=( ForwardRange& r ) + template<class Iterator> + iterator_range(Iterator first, Iterator last) + : base_type(first, last) { - m_Begin = impl::adl_begin( r ); - m_End = impl::adl_end( r ); - return *this; } - template< class ForwardRange > - iterator_range& operator=( const ForwardRange& r ) + template<class SinglePassRange> + iterator_range( + const SinglePassRange& r, + BOOST_DEDUCED_TYPENAME ::boost::enable_if< + is_compatible_range<const SinglePassRange> + >::type* = 0 + ) + : base_type(impl::adl_begin(r), impl::adl_end(r)) { - m_Begin = impl::adl_begin( r ); - m_End = impl::adl_end( r ); - return *this; } - IteratorT begin() const + template<class SinglePassRange> + iterator_range( + SinglePassRange& r, + BOOST_DEDUCED_TYPENAME ::boost::enable_if< + is_compatible_range<SinglePassRange> + >::type* = 0 + ) + : base_type(impl::adl_begin(r), impl::adl_end(r)) { - return m_Begin; } - IteratorT end() const + template<class SinglePassRange> + iterator_range(const SinglePassRange& r, + iterator_range_detail::const_range_tag) + : base_type(impl::adl_begin(r), impl::adl_end(r)) { - return m_End; } - difference_type size() const + template<class SinglePassRange> + iterator_range(SinglePassRange& r, + iterator_range_detail::range_tag) + : base_type(impl::adl_begin(r), impl::adl_end(r)) { - return m_End - m_Begin; } - bool empty() const + template<class Iterator> + iterator_range& operator=(const iterator_range<Iterator>& other) { - return m_Begin == m_End; + this->assign(other.begin(), other.end()); + return *this; } - operator unspecified_bool_type() const + template<class Iterator> + iterator_range& operator=(iterator_range<Iterator>& other) { - return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin); + this->assign(other.begin(), other.end()); + return *this; } - bool operator!() const + template<class SinglePassRange> + iterator_range& operator=(SinglePassRange& r) { - return empty(); + this->assign(r); + return *this; } - bool equal( const iterator_range& r ) const + template<class SinglePassRange> + iterator_range& operator=(const SinglePassRange& r) { - return m_Begin == r.m_Begin && m_End == r.m_End; + this->assign(r); + return *this; } - -#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - bool operator==( const iterator_range& r ) const + iterator_range& advance_begin( + BOOST_DEDUCED_TYPENAME base_type::difference_type n) { - return boost::equal( *this, r ); + std::advance(this->m_Begin, n); + return *this; } - bool operator!=( const iterator_range& r ) const + iterator_range& advance_end( + BOOST_DEDUCED_TYPENAME base_type::difference_type n) { - return !operator==(r); + std::advance(this->m_End, n); + return *this; } - bool operator<( const iterator_range& r ) const - { - return iterator_range_detail::less_than( *this, r ); - } - - bool operator>( const iterator_range& r ) const - { - return iterator_range_detail::greater_than( *this, r ); - } - - bool operator<=( const iterator_range& r ) const - { - return iterator_range_detail::less_or_equal_than( *this, r ); - } - - bool operator>=( const iterator_range& r ) const - { - return iterator_range_detail::greater_or_equal_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; - } - - // pop_front() - added to model the SinglePassRangePrimitiveConcept - void pop_front() - { - BOOST_ASSERT( !empty() ); - ++m_Begin; - } - - // pop_back() - added to model the BidirectionalRangePrimitiveConcept - void pop_back() - { - BOOST_ASSERT( !empty() ); - --m_End; - } - - 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_; @@ -381,137 +560,173 @@ namespace boost ///////////////////////////////////////////////////////////////////// // comparison operators ///////////////////////////////////////////////////////////////////// template< class IteratorT, class ForwardRange > - inline bool operator==( const ForwardRange& l, - const iterator_range<IteratorT>& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + 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 ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + 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 ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator<( const ForwardRange& l, const iterator_range<IteratorT>& r ) { return iterator_range_detail::less_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator<=( const ForwardRange& l, - const iterator_range<IteratorT>& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator<=( const ForwardRange& l, const iterator_range<IteratorT>& r ) { return iterator_range_detail::less_or_equal_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator>( const ForwardRange& l, - const iterator_range<IteratorT>& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator>( const ForwardRange& l, const iterator_range<IteratorT>& r ) { return iterator_range_detail::greater_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator>=( const ForwardRange& l, - const iterator_range<IteratorT>& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator>=( const ForwardRange& l, const iterator_range<IteratorT>& r ) { return iterator_range_detail::greater_or_equal_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 ) + 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 ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + 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 ) + 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 ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + 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 ) + 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 ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator<( const iterator_range<IteratorT>& l, const ForwardRange& r ) { return iterator_range_detail::less_than( l, r ); } template< class Iterator1T, class Iterator2T > - inline bool operator<=( const iterator_range<Iterator1T>& l, - const iterator_range<Iterator2T>& r ) + inline bool + operator<=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r ) { return iterator_range_detail::less_or_equal_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator<=( const iterator_range<IteratorT>& l, - const ForwardRange& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator<=( const iterator_range<IteratorT>& l, const ForwardRange& r ) { return iterator_range_detail::less_or_equal_than( l, r ); } template< class Iterator1T, class Iterator2T > - inline bool operator>( const iterator_range<Iterator1T>& l, - const iterator_range<Iterator2T>& r ) + inline bool + operator>( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r ) { return iterator_range_detail::greater_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator>( const iterator_range<IteratorT>& l, - const ForwardRange& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator>( const iterator_range<IteratorT>& l, const ForwardRange& r ) { return iterator_range_detail::greater_than( l, r ); } template< class Iterator1T, class Iterator2T > - inline bool operator>=( const iterator_range<Iterator1T>& l, - const iterator_range<Iterator2T>& r ) + inline bool + operator>=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r ) { return iterator_range_detail::greater_or_equal_than( l, r ); } template< class IteratorT, class ForwardRange > - inline bool operator>=( const iterator_range<IteratorT>& l, - const ForwardRange& r ) + inline BOOST_DEDUCED_TYPENAME boost::enable_if< + mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >, + bool + >::type + operator>=( const iterator_range<IteratorT>& l, const ForwardRange& r ) { return iterator_range_detail::greater_or_equal_than( l, r ); } #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING @@ -529,12 +744,19 @@ namespace boost inline iterator_range< IteratorT > make_iterator_range( IteratorT Begin, IteratorT End ) { return iterator_range<IteratorT>( Begin, End ); } + template<typename IteratorT, typename IntegerT> + inline iterator_range<IteratorT> + make_iterator_range_n(IteratorT first, IntegerT n) + { + return iterator_range<IteratorT>(first, boost::next(first, n)); + } + #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template< typename Range > inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type > make_iterator_range( Range& r ) { @@ -595,35 +817,32 @@ namespace boost 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 diff --git a/3rdParty/Boost/src/boost/range/iterator_range_io.hpp b/3rdParty/Boost/src/boost/range/iterator_range_io.hpp index 51e3a4f..8c29400 100644 --- a/3rdParty/Boost/src/boost/range/iterator_range_io.hpp +++ b/3rdParty/Boost/src/boost/range/iterator_range_io.hpp @@ -45,13 +45,13 @@ namespace boost #ifndef _STLP_NO_IOSTREAMS # ifndef BOOST_OLD_IOSTREAMS //! iterator_range output operator /*! - Output the range to an ostream. Elements are outputed + Output the range to an ostream. Elements are outputted 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 ) @@ -64,13 +64,13 @@ namespace boost } # else //! iterator_range output operator /*! - Output the range to an ostream. Elements are outputed + Output the range to an ostream. Elements are outputted in a sequence without separators. */ template< typename IteratorT > inline std::ostream& operator<<( std::ostream& Os, const iterator_range<IteratorT>& r ) diff --git a/3rdParty/Boost/src/boost/range/mutable_iterator.hpp b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp index 7beca66..b924666 100644 --- a/3rdParty/Boost/src/boost/range/mutable_iterator.hpp +++ b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp @@ -8,60 +8,72 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP #define BOOST_RANGE_MUTABLE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include <boost/range/detail/iterator.hpp> -#else - +#include <boost/range/range_fwd.hpp> #include <boost/range/detail/extract_optional_type.hpp> +#include <boost/type_traits/remove_reference.hpp> #include <boost/iterator/iterator_traits.hpp> #include <cstddef> #include <utility> namespace boost { + ////////////////////////////////////////////////////////////////////////// // default ////////////////////////////////////////////////////////////////////////// - namespace range_detail { - BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator ) - } + namespace range_detail + { - template< typename C > - struct range_mutable_iterator : range_detail::extract_iterator<C> - {}; - - ////////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////////// +BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator ) - template< typename Iterator > - struct range_mutable_iterator< std::pair<Iterator,Iterator> > - { - typedef Iterator type; - }; +template< typename C > +struct range_mutable_iterator + : range_detail::extract_iterator< + BOOST_DEDUCED_TYPENAME remove_reference<C>::type> +{}; - ////////////////////////////////////////////////////////////////////////// - // array - ////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// pair +////////////////////////////////////////////////////////////////////////// - template< typename T, std::size_t sz > - struct range_mutable_iterator< T[sz] > - { - typedef T* type; - }; +template< typename Iterator > +struct range_mutable_iterator< std::pair<Iterator,Iterator> > +{ + typedef Iterator type; +}; + +////////////////////////////////////////////////////////////////////////// +// array +////////////////////////////////////////////////////////////////////////// + +template< typename T, std::size_t sz > +struct range_mutable_iterator< T[sz] > +{ + typedef T* type; +}; + + } // namespace range_detail + +template<typename C, typename Enabler=void> +struct range_mutable_iterator + : range_detail::range_mutable_iterator< + BOOST_DEDUCED_TYPENAME remove_reference<C>::type + > +{ +}; } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#include <boost/range/detail/msvc_has_iterator_workaround.hpp> #endif diff --git a/3rdParty/Boost/src/boost/range/range_fwd.hpp b/3rdParty/Boost/src/boost/range/range_fwd.hpp new file mode 100644 index 0000000..0e6e00f --- /dev/null +++ b/3rdParty/Boost/src/boost/range/range_fwd.hpp @@ -0,0 +1,63 @@ +// Boost.Range library +// +// Copyright Neil Groves 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_RANGE_FWD_HPP_INCLUDED +#define BOOST_RANGE_RANGE_FWD_HPP_INCLUDED + +namespace boost +{ + +// Extension points + template<typename C, typename Enabler> + struct range_iterator; + + template<typename C, typename Enabler> + struct range_mutable_iterator; + + template<typename C, typename Enabler> + struct range_const_iterator; + +// Core classes + template<typename IteratorT> + class iterator_range; + + template<typename ForwardRange> + class sub_range; + +// Meta-functions + template<typename T> + struct range_category; + + template<typename T> + struct range_difference; + + template<typename T> + struct range_pointer; + + template<typename T> + struct range_reference; + + template<typename T> + struct range_reverse_iterator; + + template<typename T> + struct range_size; + + template<typename T> + struct range_value; + + template<typename T> + struct has_range_iterator; + + template<typename T> + struct has_range_const_iterator; + +} // namespace boost + +#endif // include guard diff --git a/3rdParty/Boost/src/boost/range/rbegin.hpp b/3rdParty/Boost/src/boost/range/rbegin.hpp index 78e5f61..6d66de9 100644 --- a/3rdParty/Boost/src/boost/range/rbegin.hpp +++ b/3rdParty/Boost/src/boost/range/rbegin.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_RBEGIN_HPP #define BOOST_RANGE_RBEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/end.hpp> #include <boost/range/reverse_iterator.hpp> diff --git a/3rdParty/Boost/src/boost/range/rend.hpp b/3rdParty/Boost/src/boost/range/rend.hpp index fd79aa2..ef70407 100644 --- a/3rdParty/Boost/src/boost/range/rend.hpp +++ b/3rdParty/Boost/src/boost/range/rend.hpp @@ -8,13 +8,13 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_REND_HPP #define BOOST_RANGE_REND_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/begin.hpp> #include <boost/range/reverse_iterator.hpp> diff --git a/3rdParty/Boost/src/boost/range/result_iterator.hpp b/3rdParty/Boost/src/boost/range/result_iterator.hpp deleted file mode 100644 index ba09c5f..0000000 --- a/3rdParty/Boost/src/boost/range/result_iterator.hpp +++ /dev/null @@ -1,33 +0,0 @@ -// Boost.Range library -// -// Copyright Thorsten Ottosen 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_RESULT_ITERATOR_HPP -#define BOOST_RANGE_RESULT_ITERATOR_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include <boost/range/iterator.hpp> - -namespace boost -{ - // - // This interface is deprecated, use range_iterator<T> - // - - template< typename C > - struct range_result_iterator : range_iterator<C> - { }; - -} // namespace boost - - -#endif diff --git a/3rdParty/Boost/src/boost/range/reverse_iterator.hpp b/3rdParty/Boost/src/boost/range/reverse_iterator.hpp index f8e9221..0aa0130 100644 --- a/3rdParty/Boost/src/boost/range/reverse_iterator.hpp +++ b/3rdParty/Boost/src/boost/range/reverse_iterator.hpp @@ -8,32 +8,34 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP #define BOOST_RANGE_REVERSE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/iterator.hpp> +#include <boost/type_traits/remove_reference.hpp> #include <boost/iterator/reverse_iterator.hpp> namespace boost { ////////////////////////////////////////////////////////////////////////// // default ////////////////////////////////////////////////////////////////////////// - template< typename C > + template< typename T > struct range_reverse_iterator { typedef reverse_iterator< - BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type; + BOOST_DEDUCED_TYPENAME range_iterator< + BOOST_DEDUCED_TYPENAME remove_reference<T>::type>::type > type; }; } // namespace boost diff --git a/3rdParty/Boost/src/boost/range/size.hpp b/3rdParty/Boost/src/boost/range/size.hpp index 6ae74d1..d007bfc 100644 --- a/3rdParty/Boost/src/boost/range/size.hpp +++ b/3rdParty/Boost/src/boost/range/size.hpp @@ -8,38 +8,53 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_SIZE_HPP #define BOOST_RANGE_SIZE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/size_type.hpp> +#include <boost/range/detail/has_member_size.hpp> #include <boost/assert.hpp> +#include <boost/cstdint.hpp> +#include <boost/utility.hpp> namespace boost { namespace range_detail { + + template<class SinglePassRange> + inline typename ::boost::enable_if< + has_member_size<SinglePassRange>, + typename range_size<const SinglePassRange>::type + >::type + range_calculate_size(const SinglePassRange& rng) + { + return rng.size(); + } + template<class SinglePassRange> - inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type + inline typename disable_if< + has_member_size<SinglePassRange>, + typename range_size<const SinglePassRange>::type + >::type range_calculate_size(const SinglePassRange& rng) { - BOOST_ASSERT( (boost::end(rng) - boost::begin(rng)) >= 0 && - "reachability invariant broken!" ); - return boost::end(rng) - boost::begin(rng); + return std::distance(boost::begin(rng), boost::end(rng)); } } template<class SinglePassRange> - inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type + inline typename range_size<const SinglePassRange>::type size(const SinglePassRange& rng) { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ !BOOST_WORKAROUND(__GNUC__, < 3) \ /**/ using namespace range_detail; diff --git a/3rdParty/Boost/src/boost/range/size_type.hpp b/3rdParty/Boost/src/boost/range/size_type.hpp index c6fb54b..db5a59b 100644 --- a/3rdParty/Boost/src/boost/range/size_type.hpp +++ b/3rdParty/Boost/src/boost/range/size_type.hpp @@ -8,21 +8,19 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_SIZE_TYPE_HPP #define BOOST_RANGE_SIZE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/difference_type.hpp> -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#include <boost/range/detail/size_type.hpp> -#else +#include <boost/range/concepts.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/make_unsigned.hpp> #include <boost/type_traits/remove_const.hpp> #include <cstddef> #include <utility> @@ -42,14 +40,14 @@ namespace boost typedef char no_type; struct yes_type { char dummy[2]; }; template<typename C> static yes_type test(BOOST_DEDUCED_TYPENAME C::size_type x); - template<typename C, typename Arg> - static no_type test(Arg x); + template<typename C> + static no_type test(...); public: static const bool value = sizeof(test<T>(0)) == sizeof(yes_type); }; template<typename C, typename Enabler=void> @@ -60,30 +58,41 @@ namespace boost >::type type; }; template<typename C> struct range_size< C, - BOOST_DEDUCED_TYPENAME enable_if<has_size_type<C>, void>::type + BOOST_DEDUCED_TYPENAME ::boost::enable_if<has_size_type<C>, void>::type > { typedef BOOST_DEDUCED_TYPENAME C::size_type type; }; } template< class T > struct range_size : detail::range_size<T> - { }; + { +// Very strange things happen on some compilers that have the range concept +// asserts disabled. This preprocessor condition is clearly redundant on a +// working compiler but is vital for at least some compilers such as clang 4.2 +// but only on the Mac! +#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1 + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>)); +#endif + }; template< class T > struct range_size<const T > : detail::range_size<T> - { }; + { +#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1 + BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>)); +#endif + }; } // namespace boost -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif diff --git a/3rdParty/Boost/src/boost/range/value_type.hpp b/3rdParty/Boost/src/boost/range/value_type.hpp index 95c7580..5a3187e 100644 --- a/3rdParty/Boost/src/boost/range/value_type.hpp +++ b/3rdParty/Boost/src/boost/range/value_type.hpp @@ -8,23 +8,19 @@ // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_VALUE_TYPE_HPP #define BOOST_RANGE_VALUE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif #include <boost/range/config.hpp> #include <boost/range/iterator.hpp> -//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -//#include <boost/range/detail/value_type.hpp> -//#else - #include <boost/iterator/iterator_traits.hpp> namespace boost { template< class T > struct range_value : iterator_value< typename range_iterator<T>::type > |