不要ファイル削除

This commit is contained in:
bolero-MURAKAMI 2011-09-03 22:30:50 +09:00
parent 5e67195030
commit fd1cfd05af
130 changed files with 0 additions and 6393 deletions

View file

@ -1,25 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,43 +0,0 @@
#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

View file

@ -1,41 +0,0 @@
#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

View file

@ -1,25 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,28 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,42 +0,0 @@
#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

View file

@ -1,29 +0,0 @@
#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

View file

@ -1,30 +0,0 @@
#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

View file

@ -1,43 +0,0 @@
#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

View file

@ -1,41 +0,0 @@
#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