mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-07-16 15:14:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix algorithm: bogo_sort, bozo_sort

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-02-04 01:10:26 +09:00
parent aace49ac65
commit f3b405ad0f
75 changed files with 634 additions and 776 deletions
Download patch file Download diff file Expand all files Collapse all files

20
sprout/range/algorithm/fit/clamp_range_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// clamp_range_copy
//
template<typename Input, typename Result, typename Compare>
template<typename InputRange, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fit::copy(sprout::begin(input), sprout::end(input), result);
copy(InputRange const& rng, Result const& result) {
return sprout::fit::copy(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_backward.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_backward
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fit::copy_backward(sprout::begin(input), sprout::end(input), result);
copy_backward(BidirectionalRange const& rng, Result const& result) {
return sprout::fit::copy_backward(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_if(sprout::begin(input), sprout::end(input), result, pred);
copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_until.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_until
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_until(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_until(sprout::begin(input), sprout::end(input), result, pred);
copy_until(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_until(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_while.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_while
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_while(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_while(sprout::begin(input), sprout::end(input), result, pred);
copy_while(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_while(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/merge.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/partition_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/remove_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fit::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/remove_copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/replace_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
return sprout::fit::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/replace_copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
template<typename InputRange, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
return sprout::fit::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/reverse_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// reverse_copy
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fit::reverse_copy(sprout::begin(input), sprout::end(input), result);
reverse_copy(BidirectionalRange const& rng, Result const& result) {
return sprout::fit::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/rotate_copy.hpp
View file

@ -13,14 +13,14 @@ namespace sprout {
//
// rotate_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
Result const& result
)
{
return sprout::fit::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
return sprout::fit::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_difference.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_intersection.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_symmetric_difference.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_union.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/stable_partition_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
stable_partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

10
sprout/range/algorithm/fit/swap_element_copy.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// swap_element_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng, Result const& result,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fit::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
return sprout::fit::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/transform.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
template<typename InputRange, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fit::transform(sprout::begin(input), sprout::end(input), result, op);
transform(InputRange const& rng, Result const& result, UnaryOperation op) {
return sprout::fit::transform(sprout::begin(rng), sprout::end(rng), result, op);
}
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type

12
sprout/range/algorithm/fit/unique_copy.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// unique_copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result);
unique_copy(InputRange const& rng, Result const& result) {
return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryPredicate>
template<typename InputRange, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

40
sprout/range/algorithm/fixed/clamp_range_copy.hpp
View file

@ -13,48 +13,48 @@ namespace sprout {
//
// clamp_range_copy
//
template<typename Input, typename Result, typename Compare>
template<typename InputRange, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
}
template<typename Result, typename Input, typename Compare>
template<typename Result, typename InputRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high, comp);
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high, comp);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high);
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fixed::copy(sprout::begin(input), sprout::end(input), result);
copy(InputRange const& rng, Result const& result) {
return sprout::fixed::copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy(Input const& input) {
return sprout::fixed::copy<Result>(sprout::begin(input), sprout::end(input));
copy(InputRange const& rng) {
return sprout::fixed::copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_backward.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_backward
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fixed::copy_backward(sprout::begin(input), sprout::end(input), result);
copy_backward(BidirectionalRange const& rng, Result const& result) {
return sprout::fixed::copy_backward(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename BidirectionalRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_backward(Input const& input) {
return sprout::fixed::copy_backward<Result>(sprout::begin(input), sprout::end(input));
copy_backward(BidirectionalRange const& rng) {
return sprout::fixed::copy_backward<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_if(sprout::begin(input), sprout::end(input), result);
copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_if(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_if(Input const& input, Predicate pred) {
return sprout::fixed::copy_if<Result>(sprout::begin(input), sprout::end(input));
copy_if(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_if<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_until.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_until
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_until(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_until(sprout::begin(input), sprout::end(input), result);
copy_until(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_until(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_until(Input const& input, Predicate pred) {
return sprout::fixed::copy_until<Result>(sprout::begin(input), sprout::end(input));
copy_until(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_until<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_while.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_while
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_while(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_while(sprout::begin(input), sprout::end(input), result);
copy_while(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_while(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_while(Input const& input, Predicate pred) {
return sprout::fixed::copy_while<Result>(sprout::begin(input), sprout::end(input));
copy_while(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_while<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/merge.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
merge(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/partition_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partition_copy(Input const& input, Predicate pred) {
return sprout::fixed::partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
partition_copy(InputRange const& rng, Predicate pred) {
return sprout::fixed::partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/remove_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fixed::remove_copy(sprout::begin(input), sprout::end(input), result, value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fixed::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
}
template<typename Result, typename Input, typename T>
template<typename Result, typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fixed::remove_copy<Result>(sprout::begin(input), sprout::end(input), value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fixed::remove_copy<Result>(sprout::begin(rng), sprout::end(rng), value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/remove_copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Predicate pred) {
return sprout::fixed::remove_copy_if<Result>(sprout::begin(input), sprout::end(input), pred);
remove_copy_if(InputRange const& rng, Predicate pred) {
return sprout::fixed::remove_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/replace_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
}
template<typename Result, typename Input, typename T>
template<typename Result, typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy(Input const& input, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy<Result>(sprout::begin(input), sprout::end(input), old_value, new_value);
replace_copy(InputRange const& rng, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy<Result>(sprout::begin(rng), sprout::end(rng), old_value, new_value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/replace_copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
template<typename InputRange, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
}
template<typename Result, typename Input, typename T, typename Predicate>
template<typename Result, typename InputRange, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if<Result>(sprout::begin(input), sprout::end(input), pred, new_value);
replace_copy_if(InputRange const& rng, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred, new_value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/reverse_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// reverse_copy
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fixed::reverse_copy(sprout::begin(input), sprout::end(input), result);
reverse_copy(BidirectionalRange const& rng, Result const& result) {
return sprout::fixed::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename BidirectionalRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(Input const& input) {
return sprout::fixed::reverse_copy<Result>(sprout::begin(input), sprout::end(input));
reverse_copy(BidirectionalRange const& rng) {
return sprout::fixed::reverse_copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/rotate_copy.hpp
View file

@ -13,23 +13,23 @@ namespace sprout {
//
// rotate_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
Result const& result
)
{
return sprout::fixed::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
return sprout::fixed::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle
)
{
return sprout::fixed::rotate_copy<Result>(sprout::begin(input), middle, sprout::end(input));
return sprout::fixed::rotate_copy<Result>(sprout::begin(rng), middle, sprout::end(rng));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_intersection.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_symmetric_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_union.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_union(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/stable_partition_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename BidirectionalRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
stable_partition_copy(BidirectionalRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename BidirectionalRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Predicate pred) {
return sprout::fixed::stable_partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
stable_partition_copy(BidirectionalRange const& rng, Predicate pred) {
return sprout::fixed::stable_partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

20
sprout/range/algorithm/fixed/swap_element_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// swap_element_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng, Result const& result,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fixed::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
return sprout::fixed::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fixed::swap_element_copy<Result>(sprout::begin(input), sprout::end(input), pos1, pos2);
return sprout::fixed::swap_element_copy<Result>(sprout::begin(rng), sprout::end(rng), pos1, pos2);
}
} // namespace fixed

24
sprout/range/algorithm/fixed/transform.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
template<typename InputRange, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fixed::transform(sprout::begin(input), sprout::end(input), result, op);
transform(InputRange const& rng, Result const& result, UnaryOperation op) {
return sprout::fixed::transform(sprout::begin(rng), sprout::end(rng), result, op);
}
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
template<typename InputRange1, typename InputRange2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, Result const& result, BinaryOperation op) {
return sprout::fixed::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
transform(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, BinaryOperation op) {
return sprout::fixed::transform(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), result, op);
}
template<typename Result, typename Input, typename UnaryOperation>
template<typename Result, typename InputRange, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, UnaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(input), sprout::end(input), op);
transform(InputRange const& rng, UnaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(rng), sprout::end(rng), op);
}
template<typename Result, typename Input1, typename Input2, typename BinaryOperation>
template<typename Result, typename InputRange1, typename InputRange2, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, BinaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), op);
transform(InputRange1 const& rng1, InputRange2 const& rng2, BinaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), op);
}
} // namespace fixed

24
sprout/range/algorithm/fixed/unique_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
template<typename InputRange, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
unique_copy(InputRange const& rng, Result const& result) {
return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename BinaryPredicate>
template<typename Result, typename InputRange, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, BinaryPredicate pred) {
return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input), pred);
unique_copy(InputRange const& rng, BinaryPredicate pred) {
return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input) {
return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input));
unique_copy(InputRange const& rng) {
return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed