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

最初

Browse source
This commit is contained in:
bolero-MURAKAMI 2011-09-01 02:48:32 +00:00
commit b3bb8121e8
362 changed files with 16820 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

9
sprout/range/algorithm/copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/copy.hpp>
#include <sprout/range/algorithm/outfit/copy.hpp>
#include <sprout/range/algorithm/infit/copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_COPY_HPP

9
sprout/range/algorithm/copy_backward.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_COPY_BACKWARD_HPP
#define SPROUT_RANGE_ALGORITHM_COPY_BACKWARD_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/copy_backward.hpp>
#include <sprout/range/algorithm/outfit/copy_backward.hpp>
#include <sprout/range/algorithm/infit/copy_backward.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_COPY_BACKWARD_HPP

9
sprout/range/algorithm/copy_if.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/copy_if.hpp>
#include <sprout/range/algorithm/outfit/copy_if.hpp>
#include <sprout/range/algorithm/infit/copy_if.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_COPY_IF_HPP

25
sprout/range/algorithm/fixed.hpp Normal file
View file

@ -0,0 +1,25 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/copy.hpp>
#include <sprout/range/algorithm/fixed/copy_if.hpp>
#include <sprout/range/algorithm/fixed/copy_backward.hpp>
#include <sprout/range/algorithm/fixed/transform.hpp>
#include <sprout/range/algorithm/fixed/replace_copy.hpp>
#include <sprout/range/algorithm/fixed/replace_copy_if.hpp>
#include <sprout/range/algorithm/fixed/remove_copy.hpp>
#include <sprout/range/algorithm/fixed/remove_copy_if.hpp>
#include <sprout/range/algorithm/fixed/unique_copy.hpp>
#include <sprout/range/algorithm/fixed/reverse_copy.hpp>
#include <sprout/range/algorithm/fixed/rotate_copy.hpp>
#include <sprout/range/algorithm/fixed/partition_copy.hpp>
#include <sprout/range/algorithm/fixed/stable_partition_copy.hpp>
#include <sprout/range/algorithm/fixed/merge.hpp>
#include <sprout/range/algorithm/fixed/set_union.hpp>
#include <sprout/range/algorithm/fixed/set_intersection.hpp>
#include <sprout/range/algorithm/fixed/set_difference.hpp>
#include <sprout/range/algorithm/fixed/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/fixed/swap_element_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_HPP

27
sprout/range/algorithm/fixed/copy.hpp Normal file
View file

@ -0,0 +1,27 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type copy(
Input const& input,
Result const& result
)
{
return sprout::fixed::copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_HPP

27
sprout/range/algorithm/fixed/copy_backward.hpp Normal file
View file

@ -0,0 +1,27 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_BACKWARD_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_COPY_BACKWARD_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/copy_backward.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// copy_backward
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type copy_backward(
Input const& input,
Result const& result
)
{
return sprout::fixed::copy_backward(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_BACKWARD_HPP

27
sprout/range/algorithm/fixed/copy_if.hpp Normal file
View file

@ -0,0 +1,27 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/copy_if.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// copy_if
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type copy_if(
Input const& input,
Result const& result
)
{
return sprout::fixed::copy_if(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_COPY_IF_HPP

42
sprout/range/algorithm/fixed/merge.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_MERGE_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_MERGE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/merge.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_MERGE_HPP

28
sprout/range/algorithm/fixed/partition_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/partition_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::fixed::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_PARTITION_COPY_HPP

28
sprout/range/algorithm/fixed/remove_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/remove_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_HPP

28
sprout/range/algorithm/fixed/remove_copy_if.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/remove_copy_if.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_IF_HPP

29
sprout/range/algorithm/fixed/replace_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/replace_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_HPP

29
sprout/range/algorithm/fixed/replace_copy_if.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/replace_copy_if.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_IF_HPP

27
sprout/range/algorithm/fixed/reverse_copy.hpp Normal file
View file

@ -0,0 +1,27 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_REVERSE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_REVERSE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/reverse_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// reverse_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type reverse_copy(
Input const& input,
Result const& result
)
{
return sprout::fixed::reverse_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_REVERSE_COPY_HPP

28
sprout/range/algorithm/fixed/rotate_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_ROTATE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_ROTATE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/rotate_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// rotate_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type rotate_copy(
Input const& input,
typename sprout::fixed_container_traits<Input>::const_iterator middle,
Result const& result
)
{
return sprout::fixed::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_ROTATE_COPY_HPP

42
sprout/range/algorithm/fixed/set_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_SET_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/set_difference.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_DIFFERENCE_HPP

42
sprout/range/algorithm/fixed/set_intersection.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_INTERSECTION_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_SET_INTERSECTION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/set_intersection.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_INTERSECTION_HPP

42
sprout/range/algorithm/fixed/set_symmetric_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_SYMMETRIC_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_SET_SYMMETRIC_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/set_symmetric_difference.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_SYMMETRIC_DIFFERENCE_HPP

42
sprout/range/algorithm/fixed/set_union.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_UNION_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_SET_UNION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/set_union.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_SET_UNION_HPP

28
sprout/range/algorithm/fixed/stable_partition_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_STABLE_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_STABLE_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/stable_partition_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_STABLE_PARTITION_COPY_HPP

29
sprout/range/algorithm/fixed/swap_element_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_SWAP_ELEMENT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_SWAP_ELEMENT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/swap_element_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// swap_element_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type swap_element_copy(
Input const& input,
Result const& result,
typename sprout::fixed_container_traits<Input>::const_iterator pos1,
typename sprout::fixed_container_traits<Input>::const_iterator pos2
)
{
return sprout::fixed::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_SWAP_ELEMENT_COPY_HPP

43
sprout/range/algorithm/fixed/transform.hpp Normal file
View file

@ -0,0 +1,43 @@
#ifndef SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP
#define SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/transform.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type transform(
Input const& input,
Result const& result,
UnaryOperation op
)
{
return sprout::fixed::transform(sprout::begin(input), sprout::end(input), result, op));
}
//
// transform
//
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_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);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP

40
sprout/range/algorithm/fixed/unique_copy.hpp Normal file
View file

@ -0,0 +1,40 @@
#ifndef SPROUT_RANGE_ALGORITHM_FIXED_UNIQUE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_FIXED_UNIQUE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/fixed/unique_copy.hpp>
namespace sprout {
namespace range {
namespace fixed {
//
// unique_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type unique_copy(
Input const& input,
Result const& result
)
{
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
}
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type unique_copy(
Input const& input,
Result const& result,
BinaryPredicate pred
)
{
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace fixed
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_FIXED_UNIQUE_COPY_HPP

25
sprout/range/algorithm/infit.hpp Normal file
View file

@ -0,0 +1,25 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/infit/copy.hpp>
#include <sprout/range/algorithm/infit/copy_if.hpp>
#include <sprout/range/algorithm/infit/copy_backward.hpp>
#include <sprout/range/algorithm/infit/transform.hpp>
#include <sprout/range/algorithm/infit/replace_copy.hpp>
#include <sprout/range/algorithm/infit/replace_copy_if.hpp>
#include <sprout/range/algorithm/infit/remove_copy.hpp>
#include <sprout/range/algorithm/infit/remove_copy_if.hpp>
#include <sprout/range/algorithm/infit/unique_copy.hpp>
#include <sprout/range/algorithm/infit/reverse_copy.hpp>
#include <sprout/range/algorithm/infit/rotate_copy.hpp>
#include <sprout/range/algorithm/infit/partition_copy.hpp>
#include <sprout/range/algorithm/infit/stable_partition_copy.hpp>
#include <sprout/range/algorithm/infit/merge.hpp>
#include <sprout/range/algorithm/infit/set_union.hpp>
#include <sprout/range/algorithm/infit/set_intersection.hpp>
#include <sprout/range/algorithm/infit/set_difference.hpp>
#include <sprout/range/algorithm/infit/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/infit/swap_element_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_HPP

28
sprout/range/algorithm/infit/copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy(
Input const& input,
Result const& result
)
{
return sprout::infit::copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_HPP

28
sprout/range/algorithm/infit/copy_backward.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_BACKWARD_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_COPY_BACKWARD_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/copy_backward.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// copy_backward
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy_backward(
Input const& input,
Result const& result
)
{
return sprout::infit::copy_backward(sprout::begin(input), sprout::end(input), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_BACKWARD_HPP

28
sprout/range/algorithm/infit/copy_if.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// copy_if
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy_if(
Input const& input,
Result const& result
)
{
return sprout::infit::copy_if(sprout::begin(input), sprout::end(input), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_COPY_IF_HPP

42
sprout/range/algorithm/infit/merge.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFOT_MERGE_HPP
#define SPROUT_RANGE_ALGORITHM_INFOT_MERGE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/merge.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::infit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// merge
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::infit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFOT_MERGE_HPP

29
sprout/range/algorithm/infit/partition_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/partition_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::infit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_PARTITION_COPY_HPP

29
sprout/range/algorithm/infit/remove_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/remove_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> remove_copy(
Input const& input,
Result const& result,
T const& value
)
{
return sprout::infit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_HPP

29
sprout/range/algorithm/infit/remove_copy_if.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/remove_copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> remove_copy_if(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::infit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_REMOVE_COPY_IF_HPP

30
sprout/range/algorithm/infit/replace_copy.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/replace_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> replace_copy(
Input const& input,
Result const& result,
T const& old_value,
T const& new_value
)
{
return sprout::infit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_HPP

30
sprout/range/algorithm/infit/replace_copy_if.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/replace_copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> replace_copy_if(
Input const& input,
Result const& result,
Predicate pred,
T const& new_value
)
{
return sprout::infit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_REPLACE_COPY_IF_HPP

28
sprout/range/algorithm/infit/reverse_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_REVERSE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_REVERSE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/reverse_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// reverse_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> reverse_copy(
Input const& input,
Result const& result
)
{
return sprout::infit::reverse_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_REVERSE_COPY_HPP

29
sprout/range/algorithm/infit/rotate_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_ROTATE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_ROTATE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/rotate_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// rotate_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> rotate_copy(
Input const& input,
typename sprout::fixed_container_traits<Input>::const_iterator middle,
Result const& result
)
{
return sprout::infit::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_ROTATE_COPY_HPP

42
sprout/range/algorithm/infit/set_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_INFOT_SET_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/set_difference.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::infit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_difference
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::infit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_DIFFERENCE_HPP

42
sprout/range/algorithm/infit/set_intersection.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_INTERSECTION_HPP
#define SPROUT_RANGE_ALGORITHM_INFOT_SET_INTERSECTION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/set_intersection.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::infit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::infit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_INTERSECTION_HPP

42
sprout/range/algorithm/infit/set_symmetric_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_SYMMETRIC_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_INFOT_SET_SYMMETRIC_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/set_symmetric_difference.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::infit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::infit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_SYMMETRIC_DIFFERENCE_HPP

42
sprout/range/algorithm/infit/set_union.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_UNION_HPP
#define SPROUT_RANGE_ALGORITHM_INFOT_SET_UNION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/set_union.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::infit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_union
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::infit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFOT_SET_UNION_HPP

29
sprout/range/algorithm/infit/stable_partition_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_STABLE_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_STABLE_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/stable_partition_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> stable_partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::infit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_STABLE_PARTITION_COPY_HPP

30
sprout/range/algorithm/infit/swap_element_copy.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_SWAP_ELEMENT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_SWAP_ELEMENT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/swap_element_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// swap_element_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> swap_element_copy(
Input const& input,
Result const& result,
typename sprout::fixed_container_traits<Input>::const_iterator pos1,
typename sprout::fixed_container_traits<Input>::const_iterator pos2
)
{
return sprout::infit::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_SWAP_ELEMENT_COPY_HPP

43
sprout/range/algorithm/infit/transform.hpp Normal file
View file

@ -0,0 +1,43 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_TRANSFORM_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_TRANSFORM_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/transform.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type transform(
Input const& input,
Result const& result,
UnaryOperation op
)
{
return sprout::infit::transform(sprout::begin(input), sprout::end(input), result, op));
}
//
// transform
//
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type transform(
Input1 const& input1,
Input2 const& input2,
Result const& result,
BinaryOperation op
)
{
return sprout::infit::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_TRANSFORM_HPP

41
sprout/range/algorithm/infit/unique_copy.hpp Normal file
View file

@ -0,0 +1,41 @@
#ifndef SPROUT_RANGE_ALGORITHM_INFIT_UNIQUE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_INFIT_UNIQUE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/infit/unique_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace infit {
//
// unique_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> unique_copy(
Input const& input,
Result const& result
)
{
return sprout::infit::unique_copy(sprout::begin(input), sprout::end(input), result);
}
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> unique_copy(
Input const& input,
Result const& result,
BinaryPredicate pred
)
{
return sprout::infit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace infit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_INFIT_UNIQUE_COPY_HPP

9
sprout/range/algorithm/merge.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_MERGE_HPP
#define SPROUT_RANGE_ALGORITHM_MERGE_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/merge.hpp>
#include <sprout/range/algorithm/outfit/merge.hpp>
#include <sprout/range/algorithm/infit/merge.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_MERGE_HPP

25
sprout/range/algorithm/outfit.hpp Normal file
View file

@ -0,0 +1,25 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/outfit/copy.hpp>
#include <sprout/range/algorithm/outfit/copy_if.hpp>
#include <sprout/range/algorithm/outfit/copy_backward.hpp>
#include <sprout/range/algorithm/outfit/transform.hpp>
#include <sprout/range/algorithm/outfit/replace_copy.hpp>
#include <sprout/range/algorithm/outfit/replace_copy_if.hpp>
#include <sprout/range/algorithm/outfit/remove_copy.hpp>
#include <sprout/range/algorithm/outfit/remove_copy_if.hpp>
#include <sprout/range/algorithm/outfit/unique_copy.hpp>
#include <sprout/range/algorithm/outfit/reverse_copy.hpp>
#include <sprout/range/algorithm/outfit/rotate_copy.hpp>
#include <sprout/range/algorithm/outfit/partition_copy.hpp>
#include <sprout/range/algorithm/outfit/stable_partition_copy.hpp>
#include <sprout/range/algorithm/outfit/merge.hpp>
#include <sprout/range/algorithm/outfit/set_union.hpp>
#include <sprout/range/algorithm/outfit/set_intersection.hpp>
#include <sprout/range/algorithm/outfit/set_difference.hpp>
#include <sprout/range/algorithm/outfit/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/outfit/swap_element_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_HPP

28
sprout/range/algorithm/outfit/copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy(
Input const& input,
Result const& result
)
{
return sprout::outfit::copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_HPP

28
sprout/range/algorithm/outfit/copy_backward.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_BACKWARD_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_BACKWARD_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/copy_backward.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// copy_backward
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy_backward(
Input const& input,
Result const& result
)
{
return sprout::outfit::copy_backward(sprout::begin(input), sprout::end(input), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_BACKWARD_HPP

29
sprout/range/algorithm/outfit/copy_if.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// copy_if
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> copy_if(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::outfit::copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_COPY_IF_HPP

42
sprout/range/algorithm/outfit/merge.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_MERGE_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_MERGE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/merge.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::outfit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// merge
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type merge(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::outfit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_MERGE_HPP

29
sprout/range/algorithm/outfit/partition_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/partition_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::outfit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_PARTITION_COPY_HPP

29
sprout/range/algorithm/outfit/remove_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/remove_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> remove_copy(
Input const& input,
Result const& result,
T const& value
)
{
return sprout::outfit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_HPP

29
sprout/range/algorithm/outfit/remove_copy_if.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/remove_copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> remove_copy_if(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::outfit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REMOVE_COPY_IF_HPP

30
sprout/range/algorithm/outfit/replace_copy.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/replace_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> replace_copy(
Input const& input,
Result const& result,
T const& old_value,
T const& new_value
)
{
return sprout::outfit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_HPP

30
sprout/range/algorithm/outfit/replace_copy_if.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/replace_copy_if.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> replace_copy_if(
Input const& input,
Result const& result,
Predicate pred,
T const& new_value
)
{
return sprout::outfit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REPLACE_COPY_IF_HPP

28
sprout/range/algorithm/outfit/reverse_copy.hpp Normal file
View file

@ -0,0 +1,28 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REVERSE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_REVERSE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/reverse_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// reverse_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> reverse_copy(
Input const& input,
Result const& result
)
{
return sprout::outfit::reverse_copy(sprout::begin(input), sprout::end(input), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_REVERSE_COPY_HPP

29
sprout/range/algorithm/outfit/rotate_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_ROTATE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_ROTATE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/rotate_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// rotate_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> rotate_copy(
Input const& input,
typename sprout::fixed_container_traits<Input>::const_iterator middle,
Result const& result
)
{
return sprout::outfit::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_ROTATE_COPY_HPP

42
sprout/range/algorithm/outfit/set_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_SET_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/set_difference.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::outfit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_difference
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::outfit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_DIFFERENCE_HPP

42
sprout/range/algorithm/outfit/set_intersection.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_INTERSECTION_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_SET_INTERSECTION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/set_intersection.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::outfit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_intersection(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::outfit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_INTERSECTION_HPP

42
sprout/range/algorithm/outfit/set_symmetric_difference.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_SYMMETRIC_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_SET_SYMMETRIC_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/set_symmetric_difference.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::outfit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_symmetric_difference(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::outfit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_SYMMETRIC_DIFFERENCE_HPP

42
sprout/range/algorithm/outfit/set_union.hpp Normal file
View file

@ -0,0 +1,42 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_UNION_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_SET_UNION_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/set_union.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result,
Compare comp
)
{
return sprout::outfit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
}
//
// set_union
//
template<typename Input1, typename Input2, typename Result>
SPROUT_CONSTEXPR inline typename sprout::fixed_container_traits<Result>::fixed_container_type set_union(
Input1 const& input1,
Input2 const& input2,
Result const& result
)
{
return sprout::outfit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SET_UNION_HPP

29
sprout/range/algorithm/outfit/stable_partition_copy.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_STABLE_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_STABLE_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/stable_partition_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> stable_partition_copy(
Input const& input,
Result const& result,
Predicate pred
)
{
return sprout::outfit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_STABLE_PARTITION_COPY_HPP

30
sprout/range/algorithm/outfit/swap_element_copy.hpp Normal file
View file

@ -0,0 +1,30 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SWAP_ELEMENT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_SWAP_ELEMENT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/swap_element_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// swap_element_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> swap_element_copy(
Input const& input,
Result const& result,
typename sprout::fixed_container_traits<Input>::const_iterator pos1,
typename sprout::fixed_container_traits<Input>::const_iterator pos2
)
{
return sprout::outfit::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_SWAP_ELEMENT_COPY_HPP

43
sprout/range/algorithm/outfit/transform.hpp Normal file
View file

@ -0,0 +1,43 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_TRANSFORM_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_TRANSFORM_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/transform.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> transform(
Input const& input,
Result const& result,
UnaryOperation op
)
{
return sprout::outfit::transform(sprout::begin(input), sprout::end(input), result, op));
}
//
// transform
//
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> transform(
Input1 const& input1,
Input2 const& input2,
Result const& result,
BinaryOperation op
)
{
return sprout::outfit::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_TRANSFORM_HPP

41
sprout/range/algorithm/outfit/unique_copy.hpp Normal file
View file

@ -0,0 +1,41 @@
#ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_UNIQUE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_OUTFIT_UNIQUE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/algorithm/outfit/unique_copy.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace range {
namespace outfit {
//
// unique_copy
//
template<typename Input, typename Result>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> unique_copy(
Input const& input,
Result const& result
)
{
return sprout::outfit::unique_copy(sprout::begin(input), sprout::end(input), result);
}
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
SPROUT_CONSTEXPR inline sprout::sub_array<typename sprout::fixed_container_traits<Result>::fixed_container_type> unique_copy(
Input const& input,
Result const& result,
BinaryPredicate pred
)
{
return sprout::outfit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
}
} // namespace outfit
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ALGORITHM_OUTFIT_UNIQUE_COPY_HPP

9
sprout/range/algorithm/partition_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/partition_copy.hpp>
#include <sprout/range/algorithm/outfit/partition_copy.hpp>
#include <sprout/range/algorithm/infit/partition_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP

9
sprout/range/algorithm/remove_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_REMOVE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_REMOVE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/remove_copy.hpp>
#include <sprout/range/algorithm/outfit/remove_copy.hpp>
#include <sprout/range/algorithm/infit/remove_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_REMOVE_COPY_HPP

9
sprout/range/algorithm/remove_copy_if.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_REMOVE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_REMOVE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/remove_copy_if.hpp>
#include <sprout/range/algorithm/outfit/remove_copy_if.hpp>
#include <sprout/range/algorithm/infit/remove_copy_if.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_REMOVE_COPY_IF_HPP

9
sprout/range/algorithm/replace_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_REPLACE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_REPLACE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/replace_copy.hpp>
#include <sprout/range/algorithm/outfit/replace_copy.hpp>
#include <sprout/range/algorithm/infit/replace_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_REPLACE_COPY_HPP

9
sprout/range/algorithm/replace_copy_if.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_REPLACE_COPY_IF_HPP
#define SPROUT_RANGE_ALGORITHM_REPLACE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/replace_copy_if.hpp>
#include <sprout/range/algorithm/outfit/replace_copy_if.hpp>
#include <sprout/range/algorithm/infit/replace_copy_if.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_REPLACE_COPY_IF_HPP

9
sprout/range/algorithm/reverse_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_REVERSE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_REVERSE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/reverse_copy.hpp>
#include <sprout/range/algorithm/outfit/reverse_copy.hpp>
#include <sprout/range/algorithm/infit/reverse_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_REVERSE_COPY_HPP

9
sprout/range/algorithm/rotate_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_ROTATE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_ROTATE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/rotate_copy.hpp>
#include <sprout/range/algorithm/outfit/rotate_copy.hpp>
#include <sprout/range/algorithm/infit/rotate_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_ROTATE_COPY_HPP

9
sprout/range/algorithm/set_difference.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_SET_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_SET_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/set_difference.hpp>
#include <sprout/range/algorithm/outfit/set_difference.hpp>
#include <sprout/range/algorithm/infit/set_difference.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_SET_DIFFERENCE_HPP

9
sprout/range/algorithm/set_intersection.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_SET_INTERSECTION_HPP
#define SPROUT_RANGE_ALGORITHM_SET_INTERSECTION_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/set_intersection.hpp>
#include <sprout/range/algorithm/outfit/set_intersection.hpp>
#include <sprout/range/algorithm/infit/set_intersection.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_SET_INTERSECTION_HPP

9
sprout/range/algorithm/set_symmetric_difference.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_SET_SYMMETRIC_DIFFERENCE_HPP
#define SPROUT_RANGE_ALGORITHM_SET_SYMMETRIC_DIFFERENCE_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/outfit/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/infit/set_symmetric_difference.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_SET_SYMMETRIC_DIFFERENCE_HPP

9
sprout/range/algorithm/set_union.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_SET_UNION_HPP
#define SPROUT_RANGE_ALGORITHM_SET_UNION_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/set_union.hpp>
#include <sprout/range/algorithm/outfit/set_union.hpp>
#include <sprout/range/algorithm/infit/set_union.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_SET_UNION_HPP

9
sprout/range/algorithm/stable_partition_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_STABLE_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_STABLE_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/stable_partition_copy.hpp>
#include <sprout/range/algorithm/outfit/stable_partition_copy.hpp>
#include <sprout/range/algorithm/infit/stable_partition_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_STABLE_PARTITION_COPY_HPP

9
sprout/range/algorithm/swap_element_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_SWAP_ELEMENT_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_SWAP_ELEMENT_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/swap_element_copy.hpp>
#include <sprout/range/algorithm/outfit/swap_element_copy.hpp>
#include <sprout/range/algorithm/infit/swap_element_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_SWAP_ELEMENT_COPY_HPP

9
sprout/range/algorithm/transform.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP
#define SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/transform.hpp>
#include <sprout/range/algorithm/outfit/transform.hpp>
#include <sprout/range/algorithm/infit/transform.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_TRANSFORM_HPP

9
sprout/range/algorithm/unique_copy.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef SPROUT_RANGE_ALGORITHM_UNIQUE_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_UNIQUE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/unique_copy.hpp>
#include <sprout/range/algorithm/outfit/unique_copy.hpp>
#include <sprout/range/algorithm/infit/unique_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_UNIQUE_COPY_HPP