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

fix: math functions (support for inferior C++14 standard)

Browse source 
add C++14 constexpr modifying algorithms
This commit is contained in:
bolero-MURAKAMI 2013-10-25 12:29:16 +09:00
parent 58cff54e0d
commit c58c9cc0fc
106 changed files with 3465 additions and 2144 deletions
Download patch file Download diff file Expand all files Collapse all files

4
sprout/algorithm/fill.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
//
// 25.3.6 Fill
//
template<typename ForwrdIterator, typename T>
template<typename ForwardIterator, typename T>
inline SPROUT_CXX14_CONSTEXPR void
fill(ForwrdIterator first, ForwrdIterator last, T const& value) {
fill(ForwardIterator first, ForwardIterator last, T const& value) {
while (first != last) {
*first++ = value;
}

17
sprout/algorithm/fixed/remove_copy.hpp
View file

@ -14,6 +14,8 @@
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/remove_iterator.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/pit/pit.hpp>
#include <sprout/detail/container_complate.hpp>
@ -93,7 +95,20 @@ namespace sprout {
}
} // namespace fixed
using sprout::fixed::remove_copy;
template<
typename InputIterator, typename Result, typename T,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(InputIterator first, InputIterator last, Result const& result, T const& value) {
return sprout::fixed::remove_copy(first, last, result, value);
}
template<typename Result, typename InputIterator, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(InputIterator first, InputIterator last, T const& value) {
return sprout::fixed::remove_copy<Result>(first, last, value);
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIXED_REMOVE_COPY_HPP

17
sprout/algorithm/fixed/remove_copy_if.hpp
View file

@ -14,6 +14,8 @@
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/remove_if_iterator.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/pit/pit.hpp>
#include <sprout/detail/container_complate.hpp>
@ -93,7 +95,20 @@ namespace sprout {
}
} // namespace fixed
using sprout::fixed::remove_copy_if;
template<
typename InputIterator, typename Result, typename Predicate,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(first, last, result, pred);
}
template<typename Result, typename InputIterator, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(InputIterator first, InputIterator last, Predicate pred) {
return sprout::fixed::remove_copy_if<Result>(first, last, pred);
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIXED_REMOVE_COPY_IF_HPP

15
sprout/algorithm/fixed/reverse_copy.hpp
View file

@ -137,7 +137,20 @@ namespace sprout {
}
} // namespace fixed
using sprout::fixed::reverse_copy;
template<
typename BidirectionalIterator, typename Result,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
return sprout::fixed::reverse_copy(first, last, result);
}
template<typename Result, typename BidirectionalIterator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(BidirectionalIterator first, BidirectionalIterator last) {
return sprout::fixed::reverse_copy<Result>(first, last);
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIXED_REVERSE_COPY_HPP

17
sprout/algorithm/fixed/rotate_copy.hpp
View file

@ -17,6 +17,8 @@
#include <sprout/container/indexes.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/joint_iterator.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/pit/pit.hpp>
#include <sprout/detail/container_complate.hpp>
@ -178,7 +180,20 @@ namespace sprout {
}
} // namespace fixed
using sprout::fixed::rotate_copy;
template<
typename ForwardIterator, typename Result,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, Result const& result) {
return sprout::fixed::rotate_copy(first, middle, last, result);
}
template<typename Result, typename ForwardIterator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last) {
return sprout::fixed::rotate_copy<Result>(first, middle, last);
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIXED_ROTATE_COPY_HPP

35
sprout/algorithm/fixed/unique_copy.hpp
View file

@ -14,6 +14,8 @@
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/unique_iterator.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/pit/pit.hpp>
#include <sprout/detail/container_complate.hpp>
@ -178,7 +180,38 @@ namespace sprout {
}
} // namespace fixed
using sprout::fixed::unique_copy;
template<
typename InputIterator, typename Result,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(InputIterator first, InputIterator last, Result const& result) {
return sprout::fixed::unique_copy(first, last, result);
}
template<typename Result, typename InputIterator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(InputIterator first, InputIterator last) {
return sprout::fixed::unique_copy<Result>(first, last);
}
template<
typename InputIterator, typename Result, typename BinaryPredicate,
typename sprout::enabler_if<!sprout::is_output_iterator<Result>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(InputIterator first, InputIterator last, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(first, last, result, pred);
}
template<
typename Result, typename InputIterator, typename BinaryPredicate,
typename sprout::enabler_if<!sprout::is_output_iterator<BinaryPredicate>::value>::type = sprout::enabler
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(InputIterator first, InputIterator last, BinaryPredicate pred) {
return sprout::fixed::unique_copy<Result>(first, last, pred);
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIXED_UNIQUE_COPY_HPP

4
sprout/algorithm/generate.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
//
// 25.3.7 Generate
//
template<typename ForwrdIterator, typename Generator>
template<typename ForwardIterator, typename Generator>
inline SPROUT_CXX14_CONSTEXPR void
generate(ForwrdIterator first, ForwrdIterator last, Generator gen) {
generate(ForwardIterator first, ForwardIterator last, Generator gen) {
while (first != last) {
*first++ = gen();
}

3
sprout/algorithm/modifying.hpp
View file

@ -40,11 +40,12 @@
#include <sprout/algorithm/reverse_copy.hpp>
#include <sprout/algorithm/rotate.hpp>
#include <sprout/algorithm/rotate_copy.hpp>
#include <sprout/algorithm/random_shuffle.hpp>
#include <sprout/algorithm/shuffle.hpp>
#include <sprout/algorithm/shuffle_result.hpp>
#include <sprout/algorithm/partition.hpp>
#include <sprout/algorithm/partition_copy.hpp>
#include <sprout/algorithm/stable_partition.hpp>
#include <sprout/algorithm/partition_copy.hpp>
#include <sprout/algorithm/stable_partition_copy.hpp>
#include <sprout/algorithm/sort.hpp>
#include <sprout/algorithm/stable_sort.hpp>

22
sprout/algorithm/partition.hpp
View file

@ -9,6 +9,28 @@
#define SPROUT_ALGORITHM_PARTITION_HPP
#include <sprout/config.hpp>
#include <sprout/algorithm/iter_swap.hpp>
#include <sprout/algorithm/find_if.hpp>
#include <sprout/algorithm/find_if_not.hpp>
namespace sprout {
//
// 25.3.13 Partitions
//
template<typename ForwardIterator, typename Predicate>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
partition(ForwardIterator first, ForwardIterator last, Predicate pred) {
first = sprout::find_if_not(first, last, pred);
ForwardIterator it = sprout::find_if(first, last, pred);
while (it != last) {
sprout::iter_swap(first, it);
first = sprout::find_if_not(first, last, pred);
it = sprout::find_if(it, last, pred);
}
return first;
}
} // namespace sprout
#include <sprout/algorithm/fixed/partition.hpp>
#include <sprout/algorithm/fit/partition.hpp>

11
sprout/algorithm/partition_copy.hpp
View file

@ -9,6 +9,17 @@
#define SPROUT_ALGORITHM_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/utility/pair.hpp>
namespace sprout {
//
// 25.3.13 Partitions
//
template<typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename Predicate>
inline SPROUT_CXX14_CONSTEXPR sprout::pair<OutputIterator1, OutputIterator2>
partition_copy(InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred); // !!!
} // namespace sprout
#include <sprout/algorithm/fixed/partition_copy.hpp>
#include <sprout/algorithm/fit/partition_copy.hpp>

30
sprout/algorithm/random_shuffle.hpp Normal file
View file

@ -0,0 +1,30 @@
/*=============================================================================
Copyright (c) 2011-2013 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_ALGORITHM_RANDOM_SHUFFLE_HPP
#define SPROUT_ALGORITHM_RANDOM_SHUFFLE_HPP
#include <sprout/config.hpp>
#include <sprout/algorithm/iter_swap.hpp>
namespace sprout {
//
// 25.3.12 Random shuffle
//
template<typename RandomAccessIterator, typename RandomNumberGenerator>
inline SPROUT_CXX14_CONSTEXPR void
random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator&& rand) {
if (first == last) {
return;
}
for (auto it = first + 1; it != last; ++it) {
sprout::iter_swap(it, first + rand(it - first + 1));
}
}
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_RANDOM_SHUFFLE_HPP

19
sprout/algorithm/remove.hpp
View file

@ -9,6 +9,25 @@
#define SPROUT_ALGORITHM_REMOVE_HPP
#include <sprout/config.hpp>
#include <sprout/utility/move.hpp>
namespace sprout {
//
// 25.3.8 Remove
//
template<typename ForwardIterator, typename T>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
remove(ForwardIterator first, ForwardIterator last, T const& value) {
ForwardIterator result = first;
for (; first != last; ++first) {
if (!(*first == value)) {
*result++ = sprout::move(*first);
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/remove.hpp>
#include <sprout/algorithm/fit/remove.hpp>

22
sprout/algorithm/remove_copy.hpp
View file

@ -9,6 +9,28 @@
#define SPROUT_ALGORITHM_REMOVE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
//
// 25.3.8 Remove
//
template<
typename InputIterator, typename OutputIterator, typename T,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
remove_copy(InputIterator first, InputIterator last, OutputIterator result, T const& value) {
for (; first != last; ++first) {
if (!(*first == value)) {
*result++ = *first;
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/remove_copy.hpp>
#include <sprout/algorithm/fit/remove_copy.hpp>

22
sprout/algorithm/remove_copy_if.hpp
View file

@ -9,6 +9,28 @@
#define SPROUT_ALGORITHM_REMOVE_COPY_IF_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
//
// 25.3.8 Remove
//
template<
typename InputIterator, typename OutputIterator, typename Predicate,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred) {
for (; first != last; ++first) {
if (!pred(*first)) {
*result++ = *first;
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/remove_copy_if.hpp>
#include <sprout/algorithm/fit/remove_copy_if.hpp>

19
sprout/algorithm/remove_if.hpp
View file

@ -9,6 +9,25 @@
#define SPROUT_ALGORITHM_REMOVE_IF_HPP
#include <sprout/config.hpp>
#include <sprout/utility/move.hpp>
namespace sprout {
//
// 25.3.8 Remove
//
template<typename ForwardIterator, typename Predicate>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
remove_if(ForwardIterator first, ForwardIterator last, Predicate pred) {
ForwardIterator result = first;
for (; first != last; ++first) {
if (!pred(*first)) {
*result++ = sprout::move(*first);
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/remove_if.hpp>
#include <sprout/algorithm/fit/remove_if.hpp>

4
sprout/algorithm/replace.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
//
// 25.3.5 Replace
//
template<typename ForwrdIterator, typename T>
template<typename ForwardIterator, typename T>
inline SPROUT_CXX14_CONSTEXPR void
replace(ForwrdIterator first, ForwrdIterator last, T const& old_value, T const& new_value) {
replace(ForwardIterator first, ForwardIterator last, T const& old_value, T const& new_value) {
for (; first != last; ++first) {
if (*first == old_value) {
*first = new_value;

4
sprout/algorithm/replace_if.hpp
View file

@ -14,9 +14,9 @@ namespace sprout {
//
// 25.3.5 Replace
//
template<typename ForwrdIterator, typename Predicate, typename T>
template<typename ForwardIterator, typename Predicate, typename T>
inline SPROUT_CXX14_CONSTEXPR void
replace_if(ForwrdIterator first, ForwrdIterator last, Predicate pred, T const& new_value) {
replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, T const& new_value) {
for (; first != last; ++first) {
if (pred(*first)) {
*first = new_value;

15
sprout/algorithm/reverse.hpp
View file

@ -9,6 +9,21 @@
#define SPROUT_ALGORITHM_REVERSE_HPP
#include <sprout/config.hpp>
#include <sprout/algorithm/iter_swap.hpp>
namespace sprout {
//
// 25.3.10 Reverse
//
template<typename BidirectionalIterator>
inline SPROUT_CXX14_CONSTEXPR void
reverse(BidirectionalIterator first, BidirectionalIterator last) {
for (; first != last && first != --last; ++first) {
sprout::iter_swap(first, last);
}
}
} // namespace sprout
#include <sprout/algorithm/fixed/reverse.hpp>
#include <sprout/algorithm/fit/reverse.hpp>

20
sprout/algorithm/reverse_copy.hpp
View file

@ -9,6 +9,26 @@
#define SPROUT_ALGORITHM_REVERSE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
//
// 25.3.10 Reverse
//
template<
typename BidirectionalIterator, typename OutputIterator,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result) {
while (first != last) {
*result++ = *--last;
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/reverse_copy.hpp>
#include <sprout/algorithm/fit/reverse_copy.hpp>

46
sprout/algorithm/rotate.hpp
View file

@ -8,7 +8,53 @@
#ifndef SPROUT_ALGORITHM_ROTATE_HPP
#define SPROUT_ALGORITHM_ROTATE_HPP
#include <iterator>
#include <sprout/config.hpp>
#include <sprout/algorithm/iter_swap.hpp>
namespace sprout {
//
// 25.3.11 Rotate
//
template<typename ForwardIterator>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last) {
if (first == middle) {
return last;
} else if (middle == last) {
return first;
}
ForwardIterator first2 = middle;
while (true) {
sprout::iter_swap(first, first2);
++first;
if (++first2 == last) {
break;
}
if (first == middle) {
middle = first2;
}
}
ForwardIterator result = first;
if (first != middle) {
first2 = middle;
while (true) {
sprout::iter_swap(first, first2);
++first;
if (++first2 == last) {
if (first == middle) {
break;
}
first2 = middle;
} else if (first == middle) {
middle = first2;
}
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/rotate.hpp>
#include <sprout/algorithm/fit/rotate.hpp>

18
sprout/algorithm/rotate_copy.hpp
View file

@ -9,6 +9,24 @@
#define SPROUT_ALGORITHM_ROTATE_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
#include <sprout/algorithm/copy.hpp>
namespace sprout {
//
// 25.3.11 Rotate
//
template<
typename ForwardIterator, typename OutputIterator,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result) {
return sprout::copy(first, middle, sprout::copy(middle, last, result));
}
} // namespace sprout
#include <sprout/algorithm/fixed/rotate_copy.hpp>
#include <sprout/algorithm/fit/rotate_copy.hpp>

10
sprout/algorithm/shuffle.hpp
View file

@ -9,6 +9,16 @@
#define SPROUT_ALGORITHM_SHUFFLE_HPP
#include <sprout/config.hpp>
namespace sprout {
//
// 25.3.12 Random shuffle
//
template<typename RandomAccessIterator, typename UniformRandomNumberGenerator>
inline SPROUT_CXX14_CONSTEXPR void
shuffle(RandomAccessIterator first, RandomAccessIterator last, UniformRandomNumberGenerator&& g); // !!!
} // namespace sprout
#include <sprout/algorithm/fixed/shuffle.hpp>
#include <sprout/algorithm/fit/shuffle.hpp>

11
sprout/algorithm/stable_partition.hpp
View file

@ -9,6 +9,17 @@
#define SPROUT_ALGORITHM_STABLE_PARTITION_HPP
#include <sprout/config.hpp>
namespace sprout {
//
// 25.3.13 Partitions
//
template<typename BidirectionalIterator, typename Predicate>
inline SPROUT_CXX14_CONSTEXPR BidirectionalIterator
stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); // !!!
} // namespace sprout
#include <sprout/algorithm/fixed/stable_partition.hpp>
#include <sprout/algorithm/fit/stable_partition.hpp>

43
sprout/algorithm/unique.hpp
View file

@ -8,7 +8,50 @@
#ifndef SPROUT_ALGORITHM_UNIQUE_HPP
#define SPROUT_ALGORITHM_UNIQUE_HPP
#include <iterator>
#include <sprout/config.hpp>
#include <sprout/utility/move.hpp>
namespace sprout {
//
// 25.3.9 Unique
//
template<typename ForwardIterator>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
unique(ForwardIterator first, ForwardIterator last) {
if (first == last) {
return first;
}
ForwardIterator result = first;
typename std::iterator_traits<ForwardIterator>::value_type value = sprout::move(*first++);
for (; first != last; ++first) {
if (!(value == *first)) {
*result++ = sprout::move(value);
value = sprout::move(*first);
}
}
*result++ = sprout::move(value);
return result;
}
template<typename ForwardIterator, typename BinaryPredicate>
inline SPROUT_CXX14_CONSTEXPR ForwardIterator
unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred) {
if (first == last) {
return first;
}
ForwardIterator result = first;
typename std::iterator_traits<ForwardIterator>::value_type value = sprout::move(*first++);
for (; first != last; ++first) {
if (!pred(value, *first)) {
*result++ = sprout::move(value);
value = sprout::move(*first);
}
}
*result++ = sprout::move(value);
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/unique.hpp>
#include <sprout/algorithm/fit/unique.hpp>

57
sprout/algorithm/unique_copy.hpp
View file

@ -1,14 +1,63 @@
/*=============================================================================
Copyright (c) 2011-2013 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Copyright (c) 2011-2013 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_ALGORITHM_UNIQUE_COPY_HPP
#define SPROUT_ALGORITHM_UNIQUE_COPY_HPP
#include <iterator>
#include <sprout/config.hpp>
#include <sprout/iterator/type_traits/is_iterator_of.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
//
// 25.3.9 Unique
//
template<
typename InputIterator, typename OutputIterator,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
unique_copy(InputIterator first, InputIterator last, OutputIterator result) {
if (first == last) {
return result;
}
typename std::iterator_traits<InputIterator>::value_type value = *first++;
*result++ = value;
for (; first != last; ++first) {
if (!(value == *first)) {
value = *first;
*result++ = value;
}
}
return result;
}
template<
typename InputIterator, typename OutputIterator, typename BinaryPredicate,
typename sprout::enabler_if<sprout::is_output_iterator<OutputIterator>::value>::type = sprout::enabler
>
inline SPROUT_CXX14_CONSTEXPR OutputIterator
unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred) {
if (first == last) {
return result;
}
typename std::iterator_traits<InputIterator>::value_type value = *first++;
*result++ = value;
for (; first != last; ++first) {
if (!pred(value, *first)) {
value = *first;
*result++ = value;
}
}
return result;
}
} // namespace sprout
#include <sprout/algorithm/fixed/unique_copy.hpp>
#include <sprout/algorithm/fit/unique_copy.hpp>