core/include/core/data/Stack.hpp

#ifndef CORE_STACK_HPP
#define CORE_STACK_HPP

#include "core/data/ArrayList.hpp"
#include "core/data/List.hpp"
#include "core/utils/Error.hpp"
#include "core/utils/Meta.hpp"

namespace Core {
    namespace Internal {
        template<typename T, typename S>
        class BaseStack final {
            S data{};

        public:
            template<typename... Args>
            check_return Error push(Args&&... args) {
                if constexpr(Core::IsSame<S, List<T>>) {
                    data.add(Core::forward<Args>(args)...);
                    return ErrorCode::NONE;
                } else {
                    return data.add(Core::forward<Args>(args)...);
                }
            }

            void clear() {
                data.clear();
            }

            void pop() {
                assert(data.getLength() > 0);
                data.removeBySwap(data.getLength() - 1);
            }

            bool isEmpty() const {
                return data.getLength() == 0;
            }

            T& peek() {
                assert(data.getLength() > 0);
                return data[data.getLength() - 1];
            }

            const T& peek() const {
                assert(data.getLength() > 0);
                return data[data.getLength() - 1];
            }

            template<typename String>
            check_return Error toString(String& s) const {
                return s.append(data);
            }
        };
    }

    template<typename T>
    using ListStack = Internal::BaseStack<T, List<T>>;

    template<typename T, size_t N>
    using ArrayStack = Internal::BaseStack<T, ArrayList<T, N>>;
}

#endif