stack.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <stack>
#include <stdexcept>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class Stack {
        public:
                Stack() = default;
 
                Stack(const Stack &other) : d(other.d) {}
 
                Stack(Stack &&other) noexcept : d(std::move(other.d)) {}
 
                ~Stack() = default;
 
                Stack &operator=(const Stack &other) {
                        d = other.d;
                        return *this;
                }
 
                Stack &operator=(Stack &&other) noexcept {
                        d = std::move(other.d);
                        return *this;
                }
 
                // -- Capacity --
 
                bool isEmpty() const { return d.empty(); }
 
                size_t size() const { return d.size(); }
 
                // -- Access --
 
                T &top() { return d.top(); }
 
                const T &top() const { return d.top(); }
 
                const T &constTop() const { return d.top(); }
 
                // -- Modifiers --
 
                void push(const T &value) {
                        d.push(value);
                        return;
                }
 
                void push(T &&value) {
                        d.push(std::move(value));
                        return;
                }
 
                T pop() {
                        if (d.empty()) throw std::logic_error("Stack::pop on empty stack");
                        T val = std::move(d.top());
                        d.pop();
                        return val;
                }
 
                void clear() {
                        while (!d.empty()) d.pop();
                        return;
                }
 
                void swap(Stack &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                // -- Comparison --
 
                friend bool operator==(const Stack &lhs, const Stack &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const Stack &lhs, const Stack &rhs) { return lhs.d != rhs.d; }
 
        private:
                std::stack<T> d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE