feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Neil Groves
2015-04-21 08:22:15 +01:00
parent 2356783e17 c6c4a8f3c1
commit 7669f52547
18 changed files with 180 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/boost/range/adaptor/filtered.hpp
+27 -24
View File
@@ -56,23 +56,23 @@ namespace boost
{ }
};
template< class ForwardRange, class Predicate >
inline filtered_range<Predicate, ForwardRange>
operator|(ForwardRange& r,
template< class SinglePassRange, class Predicate >
inline filtered_range<Predicate, SinglePassRange>
operator|(SinglePassRange& r,
const filter_holder<Predicate>& f)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return filtered_range<Predicate, ForwardRange>( f.val, r );
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
return filtered_range<Predicate, SinglePassRange>( f.val, r );
}
template< class ForwardRange, class Predicate >
inline filtered_range<Predicate, const ForwardRange>
operator|(const ForwardRange& r,
template< class SinglePassRange, class Predicate >
inline filtered_range<Predicate, const SinglePassRange>
operator|(const SinglePassRange& r,
const filter_holder<Predicate>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
ForwardRangeConcept<const ForwardRange>));
return filtered_range<Predicate, const ForwardRange>( f.val, r );
SinglePassRangeConcept<const SinglePassRange>));
return filtered_range<Predicate, const SinglePassRange>( f.val, r );
}
} // 'range_detail'
@@ -93,23 +93,26 @@ namespace boost
range_detail::forwarder<range_detail::filter_holder>();
}
template<class ForwardRange, class Predicate>
inline filtered_range<Predicate, ForwardRange>
filter(ForwardRange& rng, Predicate filter_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_detail::filtered_range<Predicate, ForwardRange>( filter_pred, rng );
}
template<class ForwardRange, class Predicate>
inline filtered_range<Predicate, const ForwardRange>
filter(const ForwardRange& rng, Predicate filter_pred)
template<class SinglePassRange, class Predicate>
inline filtered_range<Predicate, SinglePassRange>
filter(SinglePassRange& rng, Predicate filter_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((
ForwardRangeConcept<const ForwardRange>));
SinglePassRangeConcept<SinglePassRange>));
return range_detail::filtered_range<Predicate, const ForwardRange>( filter_pred, rng );
return range_detail::filtered_range<
Predicate, SinglePassRange>( filter_pred, rng );
}
template<class SinglePassRange, class Predicate>
inline filtered_range<Predicate, const SinglePassRange>
filter(const SinglePassRange& rng, Predicate filter_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return range_detail::filtered_range<
Predicate, const SinglePassRange>( filter_pred, rng );
}
} // 'adaptors'
include/boost/range/adaptor/strided.hpp
+1 -1
View File
@@ -603,7 +603,7 @@ namespace boost
template<
class Rng,
class Category =
typename iterator_traversal<
typename iterators::pure_iterator_traversal<
typename range_iterator<Rng>::type
>::type
>
include/boost/range/detail/common.hpp
+3 -2
View File
@@ -18,9 +18,10 @@
#include <boost/range/config.hpp>
#include <boost/range/detail/sfinae.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/or.hpp>
#include <cstddef>
//////////////////////////////////////////////////////////////////////////////
@@ -70,7 +71,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::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
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_array_ = boost::is_array<C>::value );
};
include/boost/range/difference_type.hpp
+17 -5
View File
@@ -15,20 +15,32 @@
# pragma once
#endif
#include <boost/mpl/and.hpp>
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/has_range_iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace boost
{
namespace range_detail
{
template< class T, bool B = has_type<range_iterator<T> >::value >
struct range_difference
{ };
template< class T >
struct range_difference<T, true>
: iterator_difference<
BOOST_DEDUCED_TYPENAME range_iterator<T>::type
>
{ };
}
template< class T >
struct range_difference
: iterator_difference<
BOOST_DEDUCED_TYPENAME range_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<T>::type
>::type
>
: range_detail::range_difference<BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
{ };
}
include/boost/range/iterator.hpp
+16 -18
View File
@@ -46,31 +46,29 @@ namespace boost
};
}
#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
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
};
#else
template< typename C, typename Enabler=void >
struct range_iterator
: mpl::if_c<
is_const<typename remove_reference<C>::type>::value,
range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
range_mutable_iterator<typename remove_reference<C>::type>
>::type
{
};
#endif
} // namespace boost
#endif
include/boost/range/iterator_range_core.hpp
+2 -2
View File
@@ -66,13 +66,13 @@ namespace boost
template< class ForwardRange >
static IteratorT adl_begin( ForwardRange& r )
{
return static_cast<IteratorT>( boost::begin( r ) );
return IteratorT( boost::begin( r ) );
}
template< class ForwardRange >
static IteratorT adl_end( ForwardRange& r )
{
return static_cast<IteratorT>( boost::end( r ) );
return IteratorT( boost::end( r ) );
}
};
include/boost/range/size.hpp
+9
View File
@@ -54,11 +54,20 @@ namespace boost
inline typename range_size<const SinglePassRange>::type
size(const SinglePassRange& rng)
{
// 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<SinglePassRange>));
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return range_calculate_size(rng);
}
include/boost/range/size_type.hpp
+15 -18
View File
@@ -18,6 +18,7 @@
#include <boost/range/config.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/has_range_iterator.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/make_unsigned.hpp>
@@ -51,7 +52,7 @@ namespace boost
};
template<typename C, typename Enabler=void>
struct range_size
struct range_size_
{
typedef BOOST_DEDUCED_TYPENAME make_unsigned<
BOOST_DEDUCED_TYPENAME range_difference<C>::type
@@ -59,7 +60,7 @@ namespace boost
};
template<typename C>
struct range_size<
struct range_size_<
C,
BOOST_DEDUCED_TYPENAME ::boost::enable_if<has_size_type<C>, void>::type
>
@@ -67,29 +68,25 @@ namespace boost
typedef BOOST_DEDUCED_TYPENAME C::size_type type;
};
template<typename C, bool B = range_detail::has_type< range_iterator<C> >::value>
struct range_size
{ };
template<typename C>
struct range_size<C, true>
: range_size_<C>
{ };
}
template< class T >
struct range_size :
detail::range_size<T>
{
// Very strange things happen on some compilers that have the range concept
// asserts disabled. This preprocessor condition is clearly redundant on a
// working compiler but is vital for at least some compilers such as clang 4.2
// but only on the Mac!
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
#endif
};
{ };
template< class T >
struct range_size<const T >
: detail::range_size<T>
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
#endif
};
struct range_size<const T > :
detail::range_size<T>
{ };
} // namespace boost
include/boost/range/sub_range.hpp
+2 -2
View File
@@ -182,8 +182,8 @@ public:
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
sub_range(const sub_range& r)
: base(impl::adl_begin(static_cast<const base&>(r)),
impl::adl_end(static_cast<const base&>(r)))
: base(impl::adl_begin(const_cast<base&>(static_cast<const base&>(r))),
impl::adl_end(const_cast<base&>(static_cast<const base&>(r))))
{ }
#endif