remove.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ALGORITHM_REMOVE_HPP__
#define NEFORCE_CORE_ALGORITHM_REMOVE_HPP__

 
#include "NeForce/core/algorithm/search.hpp"
#include "NeForce/core/utility/reference_wrapper.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Iterator1, typename Iterator2, typename T>
constexpr Iterator2 remove_copy(Iterator1 first, Iterator1 last, Iterator2 result, const T& value) {
    static_assert(is_ranges_fwd_iter_v<Iterator1> && is_ranges_fwd_iter_v<Iterator2>,
                  "Iterator must be forward_iterator");
 
    for (; first != last; ++first) {
        if (*first != value) {
            *result = *first;
            ++result;
        }
    }
    return result;
}

template <typename Iterator1, typename Iterator2, typename Predicate>
constexpr Iterator2 remove_copy_if(Iterator1 first, Iterator1 last, Iterator2 result, Predicate pred) {
    static_assert(is_ranges_fwd_iter_v<Iterator1> && is_ranges_fwd_iter_v<Iterator2>,
                  "Iterator must be forward_iterator");
 
    for (; first != last; ++first) {
        if (!pred(*first)) {
            *result = *first;
            ++result;
        }
    }
    return result;
}

template <typename Iterator, typename T>
constexpr Iterator remove(Iterator first, Iterator last, const T& value) {
    static_assert(is_ranges_fwd_iter_v<Iterator>, "Iterator must be forward_iterator");
 
    first = _NEFORCE find(first, last, value);
    if (first != last) {
        for (Iterator i = first; ++i != last;) {
            if (!(*i == value)) {
                *first = _NEFORCE move(*i);
                ++first;
            }
        }
    }
    return first;
}

template <typename Iterator, typename Predicate>
constexpr Iterator remove_if(Iterator first, Iterator last, Predicate pred) {
    static_assert(is_ranges_fwd_iter_v<Iterator>, "Iterator must be forward_iterator");
 
    first = _NEFORCE find_if(first, last, pred);
    if (first != last) {
        for (Iterator i = first; ++i != last;) {
            if (!pred(*i)) {
                *first = _NEFORCE move(*i);
                ++first;
            }
        }
    }
    return first;
}

template <typename Container, typename U>
constexpr size_t erase(Container& cont, const U& value) {
    using value_type = typename Container::value_type;
 
    const auto old_size = cont.size();
    const auto end = cont.end();
    auto removed = _NEFORCE remove_if(cont.begin(), end, [&value](const value_type& iter) { return iter == value; });
    cont.erase(removed, end);
    return old_size - cont.size();
}

template <typename Container, typename Predicate>
constexpr size_t erase_if(Container& cont, Predicate pred) {
    using value_type = typename Container::value_type;
 
    const size_t old_size = cont.size();
    const auto end = cont.end();
    auto removed = _NEFORCE remove_if(
            cont.begin(), end, [ref_pred = _NEFORCE ref(pred)](const value_type& iter) { return ref_pred(iter); });
    cont.erase(removed, end);
    return old_size - cont.size();
}
 // RemoveAlgorithms
 // StandardAlgorithms
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ALGORITHM_REMOVE_HPP__