deque.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <deque>
#include <initializer_list>
#include <stdexcept>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class Deque {
                PROMEKI_SHARED_FINAL(Deque)
        public:
                using Ptr = SharedPtr<Deque>;
 
                using Data = std::deque<T>;
 
                using Value = T;
 
                using Iterator = typename Data::iterator;
 
                using ConstIterator = typename Data::const_iterator;
 
                using RevIterator = typename Data::reverse_iterator;
 
                using ConstRevIterator = typename Data::const_reverse_iterator;
 
                Deque() = default;
 
                Deque(const Deque &other) : d(other.d) {}
 
                Deque(Deque &&other) noexcept : d(std::move(other.d)) {}
 
                Deque(std::initializer_list<T> initList) : d(initList) {}
 
                ~Deque() = default;
 
                Deque &operator=(const Deque &other) {
                        d = other.d;
                        return *this;
                }
 
                Deque &operator=(Deque &&other) noexcept {
                        d = std::move(other.d);
                        return *this;
                }
 
                // -- Iterators --
 
                Iterator begin() noexcept { return d.begin(); }
 
                ConstIterator begin() const noexcept { return d.cbegin(); }
 
                ConstIterator cbegin() const noexcept { return d.cbegin(); }
 
                ConstIterator constBegin() const noexcept { return d.cbegin(); }
 
                Iterator end() noexcept { return d.end(); }
 
                ConstIterator end() const noexcept { return d.cend(); }
 
                ConstIterator cend() const noexcept { return d.cend(); }
 
                ConstIterator constEnd() const noexcept { return d.cend(); }
 
                RevIterator rbegin() noexcept { return d.rbegin(); }
 
                RevIterator revBegin() noexcept { return d.rbegin(); }
 
                ConstRevIterator crbegin() const noexcept { return d.crbegin(); }
 
                ConstRevIterator constRevBegin() const noexcept { return d.crbegin(); }
 
                RevIterator rend() noexcept { return d.rend(); }
 
                RevIterator revEnd() noexcept { return d.rend(); }
 
                ConstRevIterator crend() const noexcept { return d.crend(); }
 
                ConstRevIterator constRevEnd() const noexcept { return d.crend(); }
 
                // -- Access --
 
                T &at(size_t index) { return d.at(index); }
 
                const T &at(size_t index) const { return d.at(index); }
 
                T &operator[](size_t index) { return d[index]; }
 
                const T &operator[](size_t index) const { return d[index]; }
 
                T &front() { return d.front(); }
 
                const T &front() const { return d.front(); }
 
                T &back() { return d.back(); }
 
                const T &back() const { return d.back(); }
 
                // -- Capacity --
 
                bool isEmpty() const noexcept { return d.empty(); }
 
                size_t size() const noexcept { return d.size(); }
 
                // -- Modifiers --
 
                void pushToFront(const T &value) {
                        d.push_front(value);
                        return;
                }
 
                void pushToFront(T &&value) {
                        d.push_front(std::move(value));
                        return;
                }
 
                void pushToBack(const T &value) {
                        d.push_back(value);
                        return;
                }
 
                void pushToBack(T &&value) {
                        d.push_back(std::move(value));
                        return;
                }
 
                T popFromFront() {
                        if (d.empty()) throw std::logic_error("Deque::popFromFront on empty deque");
                        T val = std::move(d.front());
                        d.pop_front();
                        return val;
                }
 
                T popFromBack() {
                        if (d.empty()) throw std::logic_error("Deque::popFromBack on empty deque");
                        T val = std::move(d.back());
                        d.pop_back();
                        return val;
                }
 
                void clear() noexcept {
                        d.clear();
                        return;
                }
 
                void swap(Deque &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                template <typename Func> void forEach(Func &&func) const {
                        for (const auto &v : d) func(v);
                        return;
                }
 
                // -- Comparison --
 
                friend bool operator==(const Deque &lhs, const Deque &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const Deque &lhs, const Deque &rhs) { return lhs.d != rhs.d; }
 
        private:
                Data d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE