dl_range_erase.h

浏览该文件的文档.

#pragma once
 
#include "base/dl_range_any.h"
 
#include <algorithm>

namespace dl::Erase
{
template<typename T, typename V>
bool HeadFromLast(T& container, const V& a)
{
    auto iter = find(container.rbegin(), container.rend(), a);
    if (iter == container.rend())
        return false;
    container.erase(container.begin(), iter.base());
    return true;
}

template<typename T, typename V>
bool TailFromLast(T& container, const V& a)
{
    auto iter = find(container.rbegin(), container.rend(), a);
    if (iter == container.rend())
        return false;
    container.erase(iter.base(), container.end());
    return true;
}

template<typename T, typename V>
bool TailFromFirst(T& container, const V& a)
{
    auto iter = find(container.begin(), container.end(), a);
    if (iter == container.end())
        return false;
    container.erase(iter, container.end());
    return true;
}

template<typename T>
void TailFromFirstSub(T& container, const T& sub)
{
    auto iter_cur = container.begin();
    auto iter_acur = sub.begin();
    auto iter_delete = iter_cur;
    bool isSuccess = false;
    for (iter_cur; iter_cur != container.end();)
    {
        while (*iter_cur == *iter_acur)
        {
            iter_cur++;
            iter_acur++;
            if (iter_acur == sub.end())
            {
                isSuccess = true;
                break;
            }
        }
        if (isSuccess)
            break;
        iter_cur++;
        iter_acur = sub.begin();
        iter_delete = iter_cur;
    }
    if (isSuccess)
        container.erase(iter_delete, container.end());
}

template<typename T>
void Match(T& a, const T& b)
{
    for (auto iter = a.begin(); iter != a.end();)
    {
        if (Any::Equal(b, *iter))
            iter = a.erase(iter);
        else
            ++iter;
    }
}

template<typename T>
T Match(const T& a, const T& b)
{
    T ret;
    for (auto& iter : a)
    {
        if (!Any::Equal(b, iter))
            ret.push_back(b);
    }
    return ret;
}

template<typename T>
bool HeadSub(T& a, const T& b)
{
    auto iter0 = std::search(a.begin(), a.end(), b.begin(), b.end());
    if (iter0 == a.end())
        return false;
    auto iter1 = iter0;
    std::advance(iter1, b.size());
    a.erase(iter0, iter1);
    return true;
}

template<typename T>
size_t AllSub(T& a, const T& b)
{
    size_t i = 0;
    while (HeadSub(a, b))
    {
        ++i;
    }
    return i;
}

template<typename C, typename V>
bool First(C& container, const V& v)
{
    for (auto iter = container.begin(); iter != container.end(); ++iter)
    {
        if (*iter == v)
        {
            container.erase(iter);
            return true;
        }
    }
    return false;
}
 
}