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

[boost][range] - Resolution of Trac ticket 4355. Made the naming of the returned types from range adaptors consistent and documented.

Browse Source 
[SVN r67420]
This commit is contained in:
Neil Groves
2010-12-22 23:42:02 +00:00
parent d68174a51d
commit dfa0764d53
127 changed files with 630 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
include/boost/range/adaptor/adjacent_filtered.hpp
View File

@ -116,7 +116,7 @@ namespace boost
};
template< class P, class R, bool default_pass >
struct adjacent_filter_range
struct adjacent_filtered_range
: iterator_range< skip_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
P,
@ -138,7 +138,7 @@ namespace boost
typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
public:
adjacent_filter_range( const P& p, R& r )
adjacent_filtered_range( const P& p, R& r )
: base_range(skip_iter(boost::begin(r), boost::end(r), p),
skip_iter(boost::end(r), boost::end(r), p))
{
@ -164,37 +164,37 @@ namespace boost
};
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
inline adjacent_filtered_range<BinPredicate, ForwardRng, true>
operator|( ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
return adjacent_filtered_range<BinPredicate, ForwardRng, true>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
inline adjacent_filtered_range<BinPredicate, const ForwardRng, true>
operator|( const ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate,
const ForwardRng, true>( f.val, r );
return adjacent_filtered_range<BinPredicate,
const ForwardRng, true>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
inline adjacent_filtered_range<BinPredicate, ForwardRng, false>
operator|( ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
return adjacent_filtered_range<BinPredicate, ForwardRng, false>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
inline adjacent_filtered_range<BinPredicate, ForwardRng, false>
operator|( const ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate,
const ForwardRng, false>( f.val, r );
return adjacent_filtered_range<BinPredicate,
const ForwardRng, false>( f.val, r );
}
} // 'range_detail'
@ -202,7 +202,7 @@ namespace boost
// Bring adjacent_filter_range into the boost namespace so that users of
// this library may specify the return type of the '|' operator and
// adjacent_filter()
using range_detail::adjacent_filter_range;
using range_detail::adjacent_filtered_range;
namespace adaptors
{
@ -218,17 +218,17 @@ namespace boost
}
template<class ForwardRng, class BinPredicate>
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
inline adjacent_filtered_range<BinPredicate, ForwardRng, true>
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
{
return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
return adjacent_filtered_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
}
template<class ForwardRng, class BinPredicate>
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
inline adjacent_filtered_range<BinPredicate, const ForwardRng, true>
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
{
return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
return adjacent_filtered_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
}
} // 'adaptors'

22
include/boost/range/adaptor/filtered.hpp
View File

@ -20,7 +20,7 @@ namespace boost
namespace range_detail
{
template< class P, class R >
struct filter_range :
struct filtered_range :
boost::iterator_range<
boost::filter_iterator< P,
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
@ -34,7 +34,7 @@ namespace boost
>
> base;
public:
filter_range( P p, R& r )
filtered_range( P p, R& r )
: base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
make_filter_iterator( p, boost::end(r), boost::end(r) ) )
{ }
@ -48,19 +48,19 @@ namespace boost
};
template< class InputRng, class Predicate >
inline filter_range<Predicate, InputRng>
inline filtered_range<Predicate, InputRng>
operator|( InputRng& r,
const filter_holder<Predicate>& f )
{
return filter_range<Predicate, InputRng>( f.val, r );
return filtered_range<Predicate, InputRng>( f.val, r );
}
template< class InputRng, class Predicate >
inline filter_range<Predicate, const InputRng>
inline filtered_range<Predicate, const InputRng>
operator|( const InputRng& r,
const filter_holder<Predicate>& f )
{
return filter_range<Predicate, const InputRng>( f.val, r );
return filtered_range<Predicate, const InputRng>( f.val, r );
}
} // 'range_detail'
@ -70,7 +70,7 @@ namespace boost
// argument dependent lookup.
// filter_range logically needs to be in the boost namespace to allow user of
// the library to define the return type for filter()
using range_detail::filter_range;
using range_detail::filtered_range;
namespace adaptors
{
@ -82,17 +82,17 @@ namespace boost
}
template<class InputRange, class Predicate>
inline filter_range<Predicate, InputRange>
inline filtered_range<Predicate, InputRange>
filter(InputRange& rng, Predicate filter_pred)
{
return range_detail::filter_range<Predicate, InputRange>( filter_pred, rng );
return range_detail::filtered_range<Predicate, InputRange>( filter_pred, rng );
}
template<class InputRange, class Predicate>
inline filter_range<Predicate, const InputRange>
inline filtered_range<Predicate, const InputRange>
filter(const InputRange& rng, Predicate filter_pred)
{
return range_detail::filter_range<Predicate, const InputRange>( filter_pred, rng );
return range_detail::filtered_range<Predicate, const InputRange>( filter_pred, rng );
}
} // 'adaptors'

22
include/boost/range/adaptor/indirected.hpp
View File

@ -19,7 +19,7 @@ namespace boost
namespace range_detail
{
template< class R >
struct indirect_range :
struct indirected_range :
public boost::iterator_range<
boost::indirect_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
@ -35,7 +35,7 @@ namespace boost
base;
public:
explicit indirect_range( R& r )
explicit indirected_range( R& r )
: base( r )
{ }
};
@ -43,22 +43,22 @@ namespace boost
struct indirect_forwarder {};
template< class InputRng >
inline indirect_range<InputRng>
inline indirected_range<InputRng>
operator|( InputRng& r, indirect_forwarder )
{
return indirect_range<InputRng>( r );
return indirected_range<InputRng>( r );
}
template< class InputRng >
inline indirect_range<const InputRng>
inline indirected_range<const InputRng>
operator|( const InputRng& r, indirect_forwarder )
{
return indirect_range<const InputRng>( r );
return indirected_range<const InputRng>( r );
}
} // 'range_detail'
using range_detail::indirect_range;
using range_detail::indirected_range;
namespace adaptors
{
@ -69,17 +69,17 @@ namespace boost
}
template<class InputRange>
inline indirect_range<InputRange>
inline indirected_range<InputRange>
indirect(InputRange& rng)
{
return indirect_range<InputRange>(rng);
return indirected_range<InputRange>(rng);
}
template<class InputRange>
inline indirect_range<const InputRange>
inline indirected_range<const InputRange>
indirect(const InputRange& rng)
{
return indirect_range<const InputRange>(rng);
return indirected_range<const InputRange>(rng);
}
} // 'adaptors'

18
include/boost/range/adaptor/map.hpp
View File

@ -62,11 +62,11 @@ namespace boost
template<class StdPairRng>
class select_first_range
: public transform_range<
: public transformed_range<
select_first<StdPairRng>,
const StdPairRng>
{
typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
typedef transformed_range<select_first<StdPairRng>, const StdPairRng> base;
public:
typedef select_first<StdPairRng> transform_fn_type;
typedef const StdPairRng source_range_type;
@ -81,11 +81,11 @@ namespace boost
template<class StdPairRng>
class select_second_mutable_range
: public transform_range<
: public transformed_range<
select_second_mutable<StdPairRng>,
StdPairRng>
{
typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
typedef transformed_range<select_second_mutable<StdPairRng>, StdPairRng> base;
public:
typedef select_second_mutable<StdPairRng> transform_fn_type;
typedef StdPairRng source_range_type;
@ -100,11 +100,11 @@ namespace boost
template<class StdPairRng>
class select_second_const_range
: public transform_range<
: public transformed_range<
select_second_const<StdPairRng>,
const StdPairRng>
{
typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
typedef transformed_range<select_second_const<StdPairRng>, const StdPairRng> base;
public:
typedef select_second_const<StdPairRng> transform_fn_type;
typedef const StdPairRng source_range_type;
@ -122,7 +122,7 @@ namespace boost
operator|( const StdPairRng& r, map_keys_forwarder )
{
return operator|( r,
boost::adaptors::transformed( select_first<StdPairRng>() ) );
boost::adaptors::transformed( select_first<StdPairRng>() ) );
}
template< class StdPairRng >
@ -130,7 +130,7 @@ namespace boost
operator|( StdPairRng& r, map_values_forwarder )
{
return operator|( r,
boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
}
template< class StdPairRng >
@ -138,7 +138,7 @@ namespace boost
operator|( const StdPairRng& r, map_values_forwarder )
{
return operator|( r,
boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
}
} // 'range_detail'

22
include/boost/range/adaptor/replaced_if.hpp
View File

@ -47,7 +47,7 @@ namespace boost
};
template< class Pred, class R >
class replace_if_range :
class replaced_if_range :
public boost::iterator_range<
boost::transform_iterator<
replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
@ -64,7 +64,7 @@ namespace boost
public:
typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
replace_if_range( R& r, const Pred& pred, value_type to )
replaced_if_range( R& r, const Pred& pred, value_type to )
: base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
make_transform_iterator( boost::end(r), Fn(pred, to) ) )
{ }
@ -87,23 +87,23 @@ namespace boost
};
template< class Pred, class InputRng >
inline replace_if_range<Pred, InputRng>
inline replaced_if_range<Pred, InputRng>
operator|( InputRng& r,
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
{
return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
return replaced_if_range<Pred, InputRng>(r, f.pred(), f.to());
}
template< class Pred, class InputRng >
inline replace_if_range<Pred, const InputRng>
inline replaced_if_range<Pred, const InputRng>
operator|( const InputRng& r,
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
{
return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
return replaced_if_range<Pred, const InputRng>(r, f.pred(), f.to());
}
} // 'range_detail'
using range_detail::replace_if_range;
using range_detail::replaced_if_range;
namespace adaptors
{
@ -115,19 +115,19 @@ namespace boost
}
template<class Pred, class InputRange>
inline replace_if_range<Pred, InputRange>
inline replaced_if_range<Pred, InputRange>
replace_if(InputRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
{
return range_detail::replace_if_range<Pred, InputRange>(rng, pred, to);
return range_detail::replaced_if_range<Pred, InputRange>(rng, pred, to);
}
template<class Pred, class InputRange>
inline replace_if_range<Pred, const InputRange>
inline replaced_if_range<Pred, const InputRange>
replace_if(const InputRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
{
return range_detail::replace_if_range<Pred, const InputRange>(rng, pred, to);
return range_detail::replaced_if_range<Pred, const InputRange>(rng, pred, to);
}
} // 'adaptors'

22
include/boost/range/adaptor/reversed.hpp
View File

@ -19,7 +19,7 @@ namespace boost
namespace range_detail
{
template< class R >
struct reverse_range :
struct reversed_range :
public boost::iterator_range<
boost::reverse_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
@ -37,7 +37,7 @@ namespace boost
public:
typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
reverse_range( R& r )
explicit reversed_range( R& r )
: base( iterator(boost::end(r)), iterator(boost::begin(r)) )
{ }
};
@ -45,22 +45,22 @@ namespace boost
struct reverse_forwarder {};
template< class BidirectionalRng >
inline reverse_range<BidirectionalRng>
inline reversed_range<BidirectionalRng>
operator|( BidirectionalRng& r, reverse_forwarder )
{
return reverse_range<BidirectionalRng>( r );
return reversed_range<BidirectionalRng>( r );
}
template< class BidirectionalRng >
inline reverse_range<const BidirectionalRng>
inline reversed_range<const BidirectionalRng>
operator|( const BidirectionalRng& r, reverse_forwarder )
{
return reverse_range<const BidirectionalRng>( r );
return reversed_range<const BidirectionalRng>( r );
}
} // 'range_detail'
using range_detail::reverse_range;
using range_detail::reversed_range;
namespace adaptors
{
@ -71,17 +71,17 @@ namespace boost
}
template<class BidirectionalRange>
inline reverse_range<BidirectionalRange>
inline reversed_range<BidirectionalRange>
reverse(BidirectionalRange& rng)
{
return reverse_range<BidirectionalRange>(rng);
return reversed_range<BidirectionalRange>(rng);
}
template<class BidirectionalRange>
inline reverse_range<const BidirectionalRange>
inline reversed_range<const BidirectionalRange>
reverse(const BidirectionalRange& rng)
{
return reverse_range<const BidirectionalRange>(rng);
return reversed_range<const BidirectionalRange>(rng);
}
} // 'adaptors'

22
include/boost/range/adaptor/tokenized.hpp
View File

@ -20,7 +20,7 @@ namespace boost
{
template< class R >
struct token_range :
struct tokenized_range :
public boost::iterator_range<
boost::regex_token_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
@ -42,7 +42,7 @@ namespace boost
public:
template< class Regex, class Submatch, class Flag >
token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
tokenized_range( R& r, const Regex& re, const Submatch& sub, Flag f )
: base( regex_iter( boost::begin(r), boost::end(r),
regex_type(re), sub, f ),
regex_iter() )
@ -90,24 +90,24 @@ namespace boost
};
template< class BidirectionalRng, class R, class S, class F >
inline token_range<BidirectionalRng>
inline tokenized_range<BidirectionalRng>
operator|( BidirectionalRng& r,
const regex_holder<R,S,F>& f )
{
return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
return tokenized_range<BidirectionalRng>( r, f.re, f.sub, f.f );
}
template< class BidirectionalRng, class R, class S, class F >
inline token_range<const BidirectionalRng>
inline tokenized_range<const BidirectionalRng>
operator|( const BidirectionalRng& r,
const regex_holder<R,S,F>& f )
{
return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
return tokenized_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
}
} // 'range_detail'
using range_detail::token_range;
using range_detail::tokenized_range;
namespace adaptors
{
@ -118,17 +118,17 @@ namespace boost
}
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
inline token_range<BidirectionalRange>
inline tokenized_range<BidirectionalRange>
tokenize(BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
{
return token_range<BidirectionalRange>(rng, reg, sub, f);
return tokenized_range<BidirectionalRange>(rng, reg, sub, f);
}
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
inline token_range<const BidirectionalRange>
inline tokenized_range<const BidirectionalRange>
tokenize(const BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
{
return token_range<const BidirectionalRange>(rng, reg, sub, f);
return tokenized_range<const BidirectionalRange>(rng, reg, sub, f);
}
} // 'adaptors'

22
include/boost/range/adaptor/transformed.hpp
View File

@ -22,7 +22,7 @@ namespace boost
{
template< class F, class R >
struct transform_range :
struct transformed_range :
public boost::iterator_range<
boost::transform_iterator< F,
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
@ -41,7 +41,7 @@ namespace boost
typedef F transform_fn_type;
typedef R source_range_type;
transform_range( F f, R& r )
transformed_range( F f, R& r )
: base( make_transform_iterator( boost::begin(r), f ),
make_transform_iterator( boost::end(r), f ) )
@ -56,24 +56,24 @@ namespace boost
};
template< class InputRng, class UnaryFunction >
inline transform_range<UnaryFunction,InputRng>
inline transformed_range<UnaryFunction,InputRng>
operator|( InputRng& r,
const transform_holder<UnaryFunction>& f )
{
return transform_range<UnaryFunction,InputRng>( f.val, r );
return transformed_range<UnaryFunction,InputRng>( f.val, r );
}
template< class InputRng, class UnaryFunction >
inline transform_range<UnaryFunction, const InputRng>
inline transformed_range<UnaryFunction, const InputRng>
operator|( const InputRng& r,
const transform_holder<UnaryFunction>& f )
{
return transform_range<UnaryFunction, const InputRng>( f.val, r );
return transformed_range<UnaryFunction, const InputRng>( f.val, r );
}
} // 'range_detail'
using range_detail::transform_range;
using range_detail::transformed_range;
namespace adaptors
{
@ -85,17 +85,17 @@ namespace boost
}
template<class UnaryFunction, class InputRange>
inline transform_range<UnaryFunction, InputRange>
inline transformed_range<UnaryFunction, InputRange>
transform(InputRange& rng, UnaryFunction fn)
{
return transform_range<UnaryFunction, InputRange>(fn, rng);
return transformed_range<UnaryFunction, InputRange>(fn, rng);
}
template<class UnaryFunction, class InputRange>
inline transform_range<UnaryFunction, const InputRange>
inline transformed_range<UnaryFunction, const InputRange>
transform(const InputRange& rng, UnaryFunction fn)
{
return transform_range<UnaryFunction, const InputRange>(fn, rng);
return transformed_range<UnaryFunction, const InputRange>(fn, rng);
}
} // 'adaptors'

24
include/boost/range/adaptor/uniqued.hpp
View File

@ -32,35 +32,35 @@ namespace boost
};
template<class ForwardRng>
class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
class uniqued_range : public adjacent_filtered_range<unique_not_equal_to, ForwardRng, true>
{
typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
typedef adjacent_filtered_range<unique_not_equal_to, ForwardRng, true> base;
public:
explicit unique_range(ForwardRng& rng)
explicit uniqued_range(ForwardRng& rng)
: base(unique_not_equal_to(), rng)
{
}
};
template< class ForwardRng >
inline unique_range<ForwardRng>
inline uniqued_range<ForwardRng>
operator|( ForwardRng& r,
unique_forwarder )
{
return unique_range<ForwardRng>(r);
return uniqued_range<ForwardRng>(r);
}
template< class ForwardRng >
inline unique_range<const ForwardRng>
inline uniqued_range<const ForwardRng>
operator|( const ForwardRng& r,
unique_forwarder )
{
return unique_range<const ForwardRng>(r);
return uniqued_range<const ForwardRng>(r);
}
} // 'range_detail'
using range_detail::unique_range;
using range_detail::uniqued_range;
namespace adaptors
{
@ -71,17 +71,17 @@ namespace boost
}
template<class ForwardRange>
inline unique_range<ForwardRange>
inline uniqued_range<ForwardRange>
unique(ForwardRange& rng)
{
return unique_range<ForwardRange>(rng);
return uniqued_range<ForwardRange>(rng);
}
template<class ForwardRange>
inline unique_range<const ForwardRange>
inline uniqued_range<const ForwardRange>
unique(const ForwardRange& rng)
{
return unique_range<const ForwardRange>(rng);
return uniqued_range<const ForwardRange>(rng);
}
} // 'adaptors'