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

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