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);
    Iterator next = first;
    return first == last ? first : _NEFORCE remove_copy(++next, last, first, value);
}

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);
    Iterator next = first;
    return first == last ? first : _NEFORCE remove_copy_if(++next, last, first, pred);
}

template <typename Container, typename U>
constexpr size_t erase(Container& cont, const U& value) {
    static_assert(declval<decltype(*cont.begin())>().operator==(declval<U>()),
                  "U must be comparable to the value type of Container");
 
    const auto old_size = cont.size();
    const auto end = cont.end();
    auto removed = _NEFORCE remove_if(cont.begin(), end, [&value](const auto& 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) {
    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 auto& 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__