ADeque.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
#include <deque>
#include "AUI/Core.h"
#include <algorithm>
#include "ASet.h"
#include <AUI/Traits/containers.h>
 

template <class StoredType,
    class Allocator = std::allocator<StoredType>>
class ADeque: public std::deque<StoredType, Allocator>
{
private:
    using p = std::deque<StoredType, Allocator>;
    using self = ADeque<StoredType, Allocator>;
public:
    using p::p;
    using iterator = typename p::iterator;
 

    template<typename OtherContainer>
    iterator insertAll(const OtherContainer& c) noexcept {
        return insertAll(p::end(), c);
    }
 

    template<typename OtherContainer>
    iterator insertAll(iterator at, const OtherContainer& c) noexcept {
        return p::insert(at, c.begin(), c.end());
    }
 

    void removeAll(const StoredType& item) noexcept
    {
        aui::container::remove_all(*this, item);
    }

    void removeFirst(const StoredType& item) noexcept
    {
        aui::container::remove_first(*this, item);
    }

    template<typename OtherContainer>
    bool isSubsetOf(const OtherContainer& c) const noexcept
    {
        return aui::container::is_subset(*this, c);
    }

    bool contains(const StoredType& value) const noexcept {
        return aui::container::contains(*this, value);
    }
 

    inline self& operator<<(const StoredType& rhs) noexcept
    {
        p::push_back(rhs);
        return *this;
    }

    inline self& operator<<(StoredType&& rhs) noexcept
    {
        p::push_back(std::move(rhs));
        return *this;
    }

    template<typename OtherContainer>
    inline self& operator<<(const OtherContainer& c) noexcept
    requires (!std::is_convertible_v<OtherContainer, StoredType>) {
        insertAll(c);
        return *this;
    }
 

    StoredType& first() noexcept
    {
        AUI_ASSERTX(!p::empty(), "empty container could not have the first element");
        return p::front();
    }

    const StoredType& first() const noexcept
    {
        AUI_ASSERTX(!p::empty(), "empty container could not have the first element");
        return p::front();
    }

    StoredType& last() noexcept
    {
        AUI_ASSERTX(!p::empty(), "empty container could not have the last element");
        return p::back();
    }

    const StoredType& last() const noexcept
    {
        AUI_ASSERTX(!p::empty(), "empty container could not have the last element");
        return p::back();
    }

    [[nodiscard]]
    AOptional<size_t> indexOf(const StoredType& value) const noexcept
    {
        return aui::container::index_of(*this, value);
    }
 
 
    void sort() noexcept {
        std::sort(p::begin(), p::end());
    }
 
    template<typename Comparator>
    void sort(Comparator&& comparator) noexcept {
        std::sort(p::begin(), p::end(), std::forward<Comparator>(comparator));
    }

    void removeAt(size_t index) noexcept
    {
        aui::container::remove_at(*this, index);
    }

    template<typename Predicate>
    void removeIf(Predicate&& predicate) noexcept
    {
        p::erase(std::remove_if(p::begin(), p::end(), std::forward<Predicate>(predicate)), p::end());
    }
 
 
    ASet<StoredType> toSet() const noexcept {
        return ASet<StoredType>(p::begin(), p::end());
    }
};
 
template<typename T>
inline std::ostream& operator<<(std::ostream& o, const ADeque<T>& v) {
    if (v.empty()) {
        o << "[empty]";
    } else {
        o << "[ " << v.first();
        for (auto it = v.begin() + 1; it != v.end(); ++it) {
            o << ", " << *it;
        }
        o << " ]";
    }
 
    return o;
}