Swiftdiff options
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 @@ -32,5 +32,5 @@ namespace boost IteratorCategoryTag2 ) { - while (true) + for (;;) { // If we have reached the end of the left range then this is @@ -72,5 +72,5 @@ namespace boost IteratorCategoryTag2 ) { - while (true) + for (;;) { // If we have reached the end of the left range then this is @@ -121,5 +121,7 @@ namespace boost RandomAccessTraversalReadableIterator2 first2, RandomAccessTraversalReadableIterator2 last2, - BinaryPredicate pred ) + BinaryPredicate pred, + std::random_access_iterator_tag, + std::random_access_iterator_tag ) { return ((last1 - first1) == (last2 - first2)) 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_BEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -27,7 +27,5 @@ 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 { @@ -86,7 +84,5 @@ namespace range_detail -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif @@ -101,7 +97,5 @@ 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 @@ -112,7 +106,5 @@ 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 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 @@ -24,4 +24,5 @@ #include <boost/range/value_type.hpp> #include <boost/range/detail/misc_concept.hpp> +#include <boost/type_traits/remove_reference.hpp> /*! @@ -64,4 +65,5 @@ namespace boost { // List broken compiler versions here: +#ifndef __clang__ #ifdef __GNUC__ // GNUC 4.2 has strange issues correctly detecting compliance with the Concepts @@ -73,4 +75,12 @@ namespace boost { #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 @@ -254,12 +264,22 @@ namespace boost { { #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 @@ -268,6 +288,6 @@ namespace boost { 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); @@ -275,11 +295,11 @@ namespace boost { 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); } @@ -288,5 +308,5 @@ namespace boost { // 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 }; @@ -302,9 +322,9 @@ namespace boost { }; - 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) @@ -314,5 +334,5 @@ namespace boost { private: iterator i; - BOOST_DEDUCED_TYPENAME range_value<Range>::type v; + BOOST_DEDUCED_TYPENAME range_value<T>::type v; #endif }; @@ -331,6 +351,6 @@ namespace boost { { #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 }; @@ -349,6 +369,6 @@ namespace boost { { #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 }; 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 @@ -14,5 +14,5 @@ #include <boost/detail/workaround.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -27,9 +27,5 @@ # 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 @@ -38,5 +34,5 @@ #endif -#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) #define BOOST_RANGE_NO_ARRAY_SUPPORT 1 #endif @@ -49,4 +45,10 @@ #endif +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) +# define BOOST_RANGE_UNUSED __attribute__((unused)) +#else +# define BOOST_RANGE_UNUSED +#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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_CONST_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -18,10 +18,8 @@ #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> @@ -33,35 +31,46 @@ namespace boost ////////////////////////////////////////////////////////////////////////// - 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_DETAIL_AS_LITERAL_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -16,7 +16,4 @@ #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 @@ -63,11 +60,4 @@ namespace boost 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) @@ -75,5 +65,4 @@ namespace boost return t; } - #endif }; 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_DETAIL_COMMON_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -15,13 +15,7 @@ #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 @@ -69,11 +63,4 @@ namespace boost 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) @@ -81,5 +68,4 @@ namespace boost return t + remove_extent<T>::size; } - #endif }; @@ -98,4 +84,3 @@ namespace boost } // 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 @@ -11,39 +11,35 @@ #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; \ }; 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 @@ -96,4 +96,15 @@ namespace boost } + 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' 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_DIFFERENCE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -19,9 +19,15 @@ #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 + > { }; } 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_DISTANCE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_EMPTY_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -29,5 +29,5 @@ namespace boost } -} // namepace 'boost' +} // namespace 'boost' 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_END_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -29,7 +29,5 @@ 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 { @@ -83,7 +81,5 @@ namespace range_detail } -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ - !BOOST_WORKAROUND(__GNUC__, < 3) \ - /**/ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) } // namespace 'range_detail' #endif @@ -95,7 +91,5 @@ 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 @@ -106,7 +100,5 @@ 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 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_FUNCTIONS_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -12,9 +12,10 @@ #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> @@ -26,47 +27,50 @@ 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 @@ -8,4 +8,8 @@ // 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 @@ -22,9 +26,18 @@ #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> @@ -76,5 +89,5 @@ namespace boost inline bool greater_than( const Left& l, const Right& r ) { - return less_than(r,l); + return iterator_range_detail::less_than(r,l); } @@ -99,6 +112,301 @@ namespace boost } - 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; + } +}; + } @@ -124,250 +432,121 @@ namespace boost 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: // @@ -385,6 +564,9 @@ namespace boost 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 ); @@ -392,6 +574,9 @@ namespace boost 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 ); @@ -399,6 +584,9 @@ namespace boost 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 ); @@ -406,6 +594,9 @@ namespace boost 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 ); @@ -413,6 +604,9 @@ namespace boost 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 ); @@ -420,6 +614,9 @@ namespace boost 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 ); @@ -429,6 +626,6 @@ namespace boost #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 ); @@ -436,6 +633,9 @@ namespace boost 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 ); @@ -444,6 +644,6 @@ namespace boost 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 ); @@ -451,6 +651,9 @@ namespace boost 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 ); @@ -459,6 +662,6 @@ namespace boost 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 ); @@ -466,6 +669,9 @@ namespace boost 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 ); @@ -473,6 +679,6 @@ namespace boost 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 ); @@ -480,6 +686,9 @@ namespace boost 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 ); @@ -487,6 +696,6 @@ namespace boost 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 ); @@ -494,6 +703,9 @@ namespace boost 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 ); @@ -501,6 +713,6 @@ namespace boost 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 ); @@ -508,6 +720,9 @@ namespace boost 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 ); @@ -533,4 +748,11 @@ namespace boost } + 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 @@ -599,5 +821,4 @@ namespace boost 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 ); } @@ -611,5 +832,4 @@ namespace boost 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 ); } @@ -621,5 +841,4 @@ namespace boost 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 ); } 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 @@ -49,5 +49,5 @@ namespace boost //! 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. */ @@ -68,5 +68,5 @@ namespace boost //! 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. */ 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_MUTABLE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -18,9 +18,7 @@ #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> @@ -29,39 +27,53 @@ 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_RBEGIN_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_REND_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_REVERSE_ITERATOR_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -18,4 +18,5 @@ #include <boost/range/config.hpp> #include <boost/range/iterator.hpp> +#include <boost/type_traits/remove_reference.hpp> #include <boost/iterator/reverse_iterator.hpp> @@ -27,9 +28,10 @@ namespace boost ////////////////////////////////////////////////////////////////////////// - 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; }; 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_SIZE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -20,5 +20,8 @@ #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 @@ -26,16 +29,28 @@ 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) { 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_SIZE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif @@ -18,7 +18,5 @@ #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> @@ -46,6 +44,6 @@ namespace boost 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: @@ -64,5 +62,5 @@ namespace boost 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 > { @@ -75,14 +73,25 @@ namespace boost 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 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 @@ -12,5 +12,5 @@ #define BOOST_RANGE_VALUE_TYPE_HPP -#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -19,8 +19,4 @@ #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> |