bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated boost on windows

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-13 21:48:48 -05:00
parent 7d77d485fd
commit b40a3bee82
5162 changed files with 473027 additions and 116452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
winx64/include/boost/range/adaptor/adjacent_filtered.hpp
View File

@@ -181,7 +181,7 @@ namespace boost
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filtered_range<BinPredicate, ForwardRng, false>
inline adjacent_filtered_range<BinPredicate, const ForwardRng, false>
operator|( const ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{

102
winx64/include/boost/range/adaptor/ref_unwrapped.hpp Normal file
View File

@@ -0,0 +1,102 @@
// Boost.Range library
//
// Copyright Robin Eckert 2015.
// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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_ADAPTOR_REF_UNWRAPPED_HPP
#define BOOST_RANGE_ADAPTOR_REF_UNWRAPPED_HPP
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/reference.hpp>
#include <boost/range/concepts.hpp>
#include <boost/type_traits/declval.hpp>
#include <utility>
#if !defined(BOOST_NO_CXX11_DECLTYPE)
namespace boost
{
namespace range_detail
{
struct ref_unwrapped_forwarder {};
template<class SinglePassRange>
struct unwrap_ref
{
typedef BOOST_DEDUCED_TYPENAME
range_reference<SinglePassRange>::type argument_type;
typedef decltype( boost::declval<argument_type>().get() ) result_type;
result_type operator()( argument_type &&r ) const
{
return r.get();
}
};
template<class SinglePassRange>
class unwrap_ref_range
: public transformed_range<unwrap_ref<SinglePassRange>,
SinglePassRange>
{
typedef transformed_range<unwrap_ref<SinglePassRange>,
SinglePassRange> base;
public:
typedef unwrap_ref<SinglePassRange> transform_fn_type;
typedef SinglePassRange source_range_type;
unwrap_ref_range(transform_fn_type fn, source_range_type &rng)
: base(fn, rng)
{
}
unwrap_ref_range(const base &other) : base(other) {}
};
template<class SinglePassRange>
inline unwrap_ref_range<SinglePassRange>
operator|(SinglePassRange& r, ref_unwrapped_forwarder)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return operator|( r,
boost::adaptors::transformed(unwrap_ref<SinglePassRange>()));
}
}
using range_detail::unwrap_ref_range;
namespace adaptors
{
namespace
{
const range_detail::ref_unwrapped_forwarder ref_unwrapped =
range_detail::ref_unwrapped_forwarder();
}
template<class SinglePassRange>
inline unwrap_ref_range<SinglePassRange>
ref_unwrap(SinglePassRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return unwrap_ref_range<SinglePassRange>(
range_detail::unwrap_ref<SinglePassRange>(), rng );
}
} // 'adaptors'
}
#endif
#endif

26
winx64/include/boost/range/adaptor/replaced.hpp
View File

@@ -101,12 +101,9 @@ namespace boost
void operator=(const replace_holder&);
};
template< class SinglePassRange >
template< class SinglePassRange, class Value >
inline replaced_range<SinglePassRange>
operator|(
SinglePassRange& r,
const replace_holder<
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f )
operator|(SinglePassRange& r, const replace_holder<Value>& f)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
@@ -114,12 +111,9 @@ namespace boost
return replaced_range<SinglePassRange>(r, f.val1, f.val2);
}
template< class SinglePassRange >
template< class SinglePassRange, class Value >
inline replaced_range<const SinglePassRange>
operator|(
const SinglePassRange& r,
const replace_holder<
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
operator|(const SinglePassRange& r, const replace_holder<Value>& f)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
@@ -139,11 +133,9 @@ namespace boost
range_detail::forwarder2<range_detail::replace_holder>();
}
template<class SinglePassRange>
template< class SinglePassRange, class Value >
inline replaced_range<SinglePassRange>
replace(SinglePassRange& rng,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
replace(SinglePassRange& rng, Value from, Value to)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
@@ -151,11 +143,9 @@ namespace boost
return replaced_range<SinglePassRange>(rng, from, to);
}
template<class SinglePassRange>
template< class SinglePassRange, class Value >
inline replaced_range<const SinglePassRange>
replace(const SinglePassRange& rng,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
replace(const SinglePassRange& rng, Value from, Value to)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));

28
winx64/include/boost/range/adaptor/replaced_if.hpp
View File

@@ -103,13 +103,9 @@ namespace boost
T m_to;
};
template< class Pred, class SinglePassRange >
template< class Pred, class SinglePassRange, class Value >
inline replaced_if_range<Pred, SinglePassRange>
operator|(
SinglePassRange& r,
const replace_if_holder<
Pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
operator|(SinglePassRange& r, const replace_if_holder<Pred, Value>& f)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
@@ -118,13 +114,9 @@ namespace boost
r, f.pred(), f.to());
}
template< class Pred, class SinglePassRange >
template< class Pred, class SinglePassRange, class Value >
inline replaced_if_range<Pred, const SinglePassRange>
operator|(
const SinglePassRange& r,
const replace_if_holder<
Pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
operator|(const SinglePassRange& r, const replace_if_holder<Pred, Value>& f)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
@@ -145,10 +137,9 @@ namespace boost
range_detail::forwarder2TU<range_detail::replace_if_holder>();
}
template<class Pred, class SinglePassRange>
template< class Pred, class SinglePassRange, class Value >
inline replaced_if_range<Pred, SinglePassRange>
replace_if(SinglePassRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
replace_if(SinglePassRange& rng, Pred pred, Value to)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
@@ -157,12 +148,9 @@ namespace boost
rng, pred, to);
}
template<class Pred, class SinglePassRange>
template< class Pred, class SinglePassRange, class Value >
inline replaced_if_range<Pred, const SinglePassRange>
replace_if(
const SinglePassRange& rng,
Pred pred,
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type to)
replace_if(const SinglePassRange& rng, Pred pred, Value to)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));

1
winx64/include/boost/range/adaptor/sliced.hpp
View File

@@ -15,6 +15,7 @@
#include <boost/range/size_type.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/next_prior.hpp>
namespace boost
{

18
winx64/include/boost/range/algorithm/max_element.hpp
View File

@@ -9,12 +9,12 @@
#ifndef BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
#define BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
#include <boost/algorithm/minmax_element.hpp>
#include <boost/concept_check.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/detail/range_return.hpp>
#include <algorithm>
namespace boost
{
@@ -32,7 +32,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
return boost::first_max_element(boost::begin(rng), boost::end(rng));
}
/// \overload
@@ -41,7 +41,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
return boost::first_max_element(boost::begin(rng), boost::end(rng));
}
/// \overload
@@ -50,7 +50,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
return boost::first_max_element(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
@@ -59,7 +59,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
return boost::first_max_element(boost::begin(rng), boost::end(rng), pred);
}
// range_return overloads
@@ -71,7 +71,7 @@ max_element(ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
boost::first_max_element(boost::begin(rng), boost::end(rng)),
rng);
}
@@ -82,7 +82,7 @@ max_element(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
boost::first_max_element(boost::begin(rng), boost::end(rng)),
rng);
}
@@ -93,7 +93,7 @@ max_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
boost::first_max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
@@ -104,7 +104,7 @@ max_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
boost::first_max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}

18
winx64/include/boost/range/algorithm/min_element.hpp
View File

@@ -9,12 +9,12 @@
#ifndef BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
#define BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
#include <boost/algorithm/minmax_element.hpp>
#include <boost/concept_check.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/detail/range_return.hpp>
#include <algorithm>
namespace boost
{
@@ -32,7 +32,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
return boost::first_min_element(boost::begin(rng), boost::end(rng));
}
/// \overload
@@ -41,7 +41,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
return boost::first_min_element(boost::begin(rng), boost::end(rng));
}
/// \overload
@@ -50,7 +50,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
return boost::first_min_element(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
@@ -59,7 +59,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
return boost::first_min_element(boost::begin(rng), boost::end(rng), pred);
}
// range_return overloads
@@ -71,7 +71,7 @@ min_element(ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
boost::first_min_element(boost::begin(rng), boost::end(rng)),
rng);
}
@@ -82,7 +82,7 @@ min_element(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
boost::first_min_element(boost::begin(rng), boost::end(rng)),
rng);
}
@@ -93,7 +93,7 @@ min_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
boost::first_min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
@@ -104,7 +104,7 @@ min_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
boost::first_min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}

81
winx64/include/boost/range/algorithm/random_shuffle.hpp
View File

@@ -14,12 +14,85 @@
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <algorithm>
#ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE
#include <cstdlib>
#endif
namespace boost
{
namespace range
{
namespace detail
{
#ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE
// wrap std::rand as UniformRandomBitGenerator
struct wrap_rand
{
typedef unsigned int result_type;
static BOOST_CONSTEXPR result_type (min)()
{
return 0;
}
static BOOST_CONSTEXPR result_type (max)()
{
return RAND_MAX;
}
result_type operator()()
{
return std::rand();
}
};
template< class RandomIt >
inline void random_shuffle(RandomIt first, RandomIt last)
{
std::shuffle(first, last, wrap_rand());
}
// wrap Generator as UniformRandomBitGenerator
template< class Generator >
struct wrap_generator
{
typedef unsigned int result_type;
static const int max_arg = ((0u - 1u) >> 2) + 1;
Generator& g;
wrap_generator(Generator& gen) : g(gen) {}
static BOOST_CONSTEXPR result_type (min)()
{
return 0;
}
static BOOST_CONSTEXPR result_type (max)()
{
return max_arg - 1;
}
result_type operator()()
{
return static_cast<result_type>(g(max_arg));
}
};
template< class RandomIt, class Generator >
inline void random_shuffle(RandomIt first, RandomIt last, Generator& gen)
{
std::shuffle(first, last, wrap_generator< Generator >(gen));
}
#else
using std::random_shuffle;
#endif
} // namespace detail
/// \brief template function random_shuffle
///
/// range-based version of the random_shuffle std algorithm
@@ -30,7 +103,7 @@ template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng));
detail::random_shuffle(boost::begin(rng), boost::end(rng));
return rng;
}
@@ -39,7 +112,7 @@ template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng));
detail::random_shuffle(boost::begin(rng), boost::end(rng));
return rng;
}
@@ -48,7 +121,7 @@ template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
detail::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
@@ -57,7 +130,7 @@ template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
detail::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}

1
winx64/include/boost/range/algorithm_ext/insert.hpp
View File

@@ -39,6 +39,7 @@ inline Container& insert( Container& on, const Range& from )
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
on.insert(boost::begin(from), boost::end(from));
return on;
}
} // namespace range

43
winx64/include/boost/range/as_literal.hpp
View File

@@ -25,6 +25,11 @@
#include <boost/detail/workaround.hpp>
#include <cstring>
#if !defined(BOOST_NO_CXX11_CHAR16_T) || !defined(BOOST_NO_CXX11_CHAR32_T)
#include <string> // for std::char_traits
#endif
#ifndef BOOST_NO_CWCHAR
#include <cwchar>
#endif
@@ -38,6 +43,20 @@ namespace boost
return strlen( s );
}
#ifndef BOOST_NO_CXX11_CHAR16_T
inline std::size_t length( const char16_t* s )
{
return std::char_traits<char16_t>::length( s );
}
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
inline std::size_t length( const char32_t* s )
{
return std::char_traits<char32_t>::length( s );
}
#endif
#ifndef BOOST_NO_CWCHAR
inline std::size_t length( const wchar_t* s )
{
@@ -61,6 +80,30 @@ namespace boost
return true;
}
#ifndef BOOST_NO_CXX11_CHAR16_T
inline bool is_char_ptr( char16_t* )
{
return true;
}
inline bool is_char_ptr( const char16_t* )
{
return true;
}
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
inline bool is_char_ptr( char32_t* )
{
return true;
}
inline bool is_char_ptr( const char32_t* )
{
return true;
}
#endif
#ifndef BOOST_NO_CWCHAR
inline bool is_char_ptr( wchar_t* )
{

18
winx64/include/boost/range/begin.hpp
View File

@@ -22,6 +22,8 @@
#else
#include <boost/range/iterator.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
namespace boost
{
@@ -36,7 +38,7 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
range_begin( C& c )
{
//
@@ -52,13 +54,13 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
BOOST_CONSTEXPR inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
{
return p.first;
}
template< typename Iterator >
inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
BOOST_CONSTEXPR inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
{
return p.first;
}
@@ -71,13 +73,13 @@ namespace range_detail
// May this be discarded? Or is it needed for bad compilers?
//
template< typename T, std::size_t sz >
inline const T* range_begin( const T (&a)[sz] )
BOOST_CONSTEXPR inline const T* range_begin( const T (&a)[sz] ) BOOST_NOEXCEPT
{
return a;
}
template< typename T, std::size_t sz >
inline T* range_begin( T (&a)[sz] )
BOOST_CONSTEXPR inline T* range_begin( T (&a)[sz] ) BOOST_NOEXCEPT
{
return a;
}
@@ -94,6 +96,9 @@ namespace range_adl_barrier
{
template< class T >
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_CONSTEXPR
#endif
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -103,6 +108,9 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
}
template< class T >
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_CONSTEXPR
#endif
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

12
winx64/include/boost/range/concepts.hpp
View File

@@ -25,6 +25,8 @@
#include <boost/range/detail/misc_concept.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <iterator>
/*!
* \file
* \brief Concept checks for the Boost Range library.
@@ -164,10 +166,10 @@ namespace boost {
// work
(void)(i++);
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r1(*i);
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r1(*i);
boost::ignore_unused_variable_warning(r1);
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r2(*(++i));
boost::ignore_unused_variable_warning(r2);
}
private:
@@ -181,7 +183,7 @@ namespace boost {
, DefaultConstructible<Iterator>
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::difference_type difference_type;
BOOST_MPL_ASSERT((is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
@@ -200,7 +202,7 @@ namespace boost {
// is convertible to reference.
Iterator i2(i++);
boost::ignore_unused_variable_warning(i2);
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r(*(i++));
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r(*(i++));
boost::ignore_unused_variable_warning(r);
}
private:
@@ -250,7 +252,7 @@ namespace boost {
n = i - j;
}
private:
BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept<Iterator>::difference_type n;
Iterator i;
Iterator j;
#endif

8
winx64/include/boost/range/detail/begin.hpp
View File

@@ -32,7 +32,7 @@ namespace boost
struct range_begin<std_container_>
{
template< typename C >
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
{
return c.begin();
};
@@ -46,7 +46,7 @@ namespace boost
struct range_begin<std_pair_>
{
template< typename P >
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
{
return p.first;
}
@@ -60,7 +60,7 @@ namespace boost
struct range_begin<array_>
{
template<typename T>
static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
{
return t;
}
@@ -71,7 +71,7 @@ namespace boost
namespace range_adl_barrier
{
template< typename C >
inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
BOOST_CONSTEXPR inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
begin( C& c )
{
return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );

4
winx64/include/boost/range/detail/common.hpp
View File

@@ -18,10 +18,8 @@
#include <boost/range/config.hpp>
#include <boost/range/detail/sfinae.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/or.hpp>
#include <cstddef>
//////////////////////////////////////////////////////////////////////////////
@@ -71,7 +69,7 @@ namespace boost
BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::mpl::or_<boost::mpl::bool_<is_const_char_ptr_>, boost::mpl::bool_<is_const_wchar_t_ptr_> >::value ));
BOOST_STATIC_CONSTANT( bool, is_string_ = (is_const_char_ptr_ || is_const_wchar_t_ptr_));
BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array<C>::value );
};

17
winx64/include/boost/range/detail/default_constructible_unary_fn.hpp
View File

@@ -32,6 +32,23 @@ public:
: m_impl(source)
{
}
default_constructible_unary_fn_wrapper(const default_constructible_unary_fn_wrapper& source)
: m_impl(source.m_impl)
{
}
default_constructible_unary_fn_wrapper& operator=(const default_constructible_unary_fn_wrapper& source)
{
if (source.m_impl)
{
// Lambda are not copy/move assignable.
m_impl.emplace(*source.m_impl);
}
else
{
m_impl.reset();
}
return *this;
}
template<typename Arg>
R operator()(const Arg& arg) const
{

8
winx64/include/boost/range/detail/end.hpp
View File

@@ -33,7 +33,7 @@ namespace boost
struct range_end<std_container_>
{
template< typename C >
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
fun( C& c )
{
return c.end();
@@ -48,7 +48,7 @@ namespace boost
struct range_end<std_pair_>
{
template< typename P >
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
fun( const P& p )
{
return p.second;
@@ -63,7 +63,7 @@ namespace boost
struct range_end<array_>
{
template<typename T>
static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
BOOST_CONSTEXPR static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
{
return t + remove_extent<T>::size;
}
@@ -74,7 +74,7 @@ namespace boost
namespace range_adl_barrier
{
template< typename C >
inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
BOOST_CONSTEXPR inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
end( C& c )
{
return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );

4
winx64/include/boost/range/detail/implementation_help.hpp
View File

@@ -60,13 +60,13 @@ namespace boost
}
template< class T, std::size_t sz >
inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
BOOST_CONSTEXPR inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] ) BOOST_NOEXCEPT
{
return boost_range_array + sz;
}
template< class T, std::size_t sz >
inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
BOOST_CONSTEXPR inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] ) BOOST_NOEXCEPT
{
return boost_range_array + sz;
}

8
winx64/include/boost/range/detail/join_iterator.hpp
View File

@@ -153,8 +153,12 @@ template<typename Iterator1
typename iterator_reference<Iterator2>::type
>::type
>::value,
typename add_const<
typename iterator_reference<Iterator1>::type
typename add_reference<
typename add_const<
typename remove_reference<
typename iterator_reference<Iterator1>::type
>::type
>::type
>::type,
typename iterator_reference<Iterator1>::type
>::type

1
winx64/include/boost/range/detail/microsoft.hpp
View File

@@ -58,6 +58,7 @@
#include <boost/type_traits/remove_cv.hpp>
#include <boost/utility/addressof.hpp>
#include <boost/utility/enable_if.hpp> // disable_if
#include <boost/next_prior.hpp>
#if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
#include <boost/range/mutable_iterator.hpp>

1
winx64/include/boost/range/detail/range_return.hpp
View File

@@ -12,6 +12,7 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/next_prior.hpp>
namespace boost
{

16
winx64/include/boost/range/distance.hpp
View File

@@ -15,20 +15,26 @@
# pragma once
#endif
#include <boost/iterator/distance.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/difference_type.hpp>
namespace boost
namespace boost
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_difference<T>::type
distance( const T& r )
namespace range_distance_adl_barrier
{
return std::distance( boost::begin( r ), boost::end( r ) );
template< class T >
inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME range_difference<T>::type
distance( const T& r )
{
return boost::iterators::distance( boost::begin( r ), boost::end( r ) );
}
}
using namespace range_distance_adl_barrier;
} // namespace 'boost'
#endif

20
winx64/include/boost/range/end.hpp
View File

@@ -24,6 +24,8 @@
#include <boost/range/detail/implementation_help.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
namespace boost
{
@@ -37,7 +39,7 @@ namespace range_detail
// primary template
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
range_end( C& c )
{
//
@@ -53,13 +55,13 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
BOOST_CONSTEXPR inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
{
return p.second;
}
template< typename Iterator >
inline Iterator range_end( std::pair<Iterator,Iterator>& p )
BOOST_CONSTEXPR inline Iterator range_end( std::pair<Iterator,Iterator>& p )
{
return p.second;
}
@@ -69,13 +71,13 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
inline const T* range_end( const T (&a)[sz] )
BOOST_CONSTEXPR inline const T* range_end( const T (&a)[sz] ) BOOST_NOEXCEPT
{
return range_detail::array_end<T,sz>( a );
}
template< typename T, std::size_t sz >
inline T* range_end( T (&a)[sz] )
BOOST_CONSTEXPR inline T* range_end( T (&a)[sz] ) BOOST_NOEXCEPT
{
return range_detail::array_end<T,sz>( a );
}
@@ -88,6 +90,9 @@ namespace range_adl_barrier
{
template< class T >
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_CONSTEXPR
#endif
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -97,6 +102,9 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
}
template< class T >
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_CONSTEXPR
#endif
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@@ -115,7 +123,7 @@ namespace boost
namespace range_adl_barrier
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
BOOST_CONSTEXPR inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
const_end( const T& r )
{
return boost::range_adl_barrier::end( r );

6
winx64/include/boost/range/has_range_iterator.hpp
View File

@@ -37,9 +37,9 @@ namespace boost
T,
BOOST_DEDUCED_TYPENAME ::boost::enable_if<
BOOST_DEDUCED_TYPENAME mpl::eval_if<is_const<T>,
has_type<range_const_iterator<
has_type<boost::range_const_iterator<
BOOST_DEDUCED_TYPENAME remove_const<T>::type> >,
has_type<range_mutable_iterator<T> >
has_type<boost::range_mutable_iterator<T> >
>::type
>::type
>
@@ -57,7 +57,7 @@ namespace boost
struct has_range_const_iterator_impl<
T,
BOOST_DEDUCED_TYPENAME ::boost::enable_if<
has_type<range_const_iterator<T> >
has_type<boost::range_const_iterator<T> >
>::type
>
: boost::mpl::true_

11
winx64/include/boost/range/irange.hpp
View File

@@ -217,7 +217,7 @@ namespace boost
{
BOOST_ASSERT( step_size != 0 );
BOOST_ASSERT( (step_size > 0) ? (last >= first) : (last <= first) );
typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;
const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step_size >= 0 ? step_size : -step_size);
@@ -225,12 +225,19 @@ namespace boost
const Integer f = step_size >= 0 ? first : last;
const std::ptrdiff_t num_steps = (l - f) / sz + ((l - f) % sz ? 1 : 0);
BOOST_ASSERT(num_steps >= 0);
return strided_integer_range<Integer>(
iterator_t(first, 0, step_size),
iterator_t(first, num_steps, step_size));
}
template<typename Integer>
integer_range<Integer>
irange(Integer last)
{
return integer_range<Integer>(static_cast<Integer>(0), last);
}
} // namespace boost
#endif // include guard

1
winx64/include/boost/range/iterator_range_core.hpp
View File

@@ -42,6 +42,7 @@
#include <boost/range/algorithm/equal.hpp>
#include <boost/range/detail/safe_bool.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/next_prior.hpp>
#include <iterator>
#include <algorithm>
#include <cstddef>