ArrayStack.hpp

//
// Created by Hamza El-Kebir on 6/15/21.
//
 
#ifndef LODESTAR_ARRAYSTACK_HPP
#define LODESTAR_ARRAYSTACK_HPP
 
#include <array>
#include <cassert>
#include <stdexcept>
 
namespace ls {
    namespace aux {
        template<typename TType, size_t TSize>
        struct ArrayStack {
        public:
            ArrayStack() : size_(0)
            {}
 
            using type = ArrayStack<TType, TSize>;
            using arrayType = std::array<TType, TSize>;
 
            static type zero()
            {
                type a;
                a.fill(TType{});
 
                return a;
            }
 
            inline size_t size() const noexcept
            {
                return size_;
            }
 
            inline constexpr size_t max_size() const noexcept
            {
                return TSize;
            }
 
            inline void clear() noexcept
            {
                size_ = 0;
            }
 
            inline TType &operator[](size_t idx)
            {
                if (idx < 0)
                    throw std::out_of_range("ArrayStack index less than zero.");
                if (idx >= size_)
                    throw std::out_of_range("ArrayStack index greater than size.");
 
                return array_[idx];
            }
 
            inline const TType &operator[](size_t idx) const
            {
                if (idx < 0)
                    throw std::out_of_range("ArrayStack index less than zero.");
                if (idx >= size_)
                    throw std::out_of_range("ArrayStack index greater than size.");
 
                return array_[idx];
            }
 
            inline void fill(const TType &value)
            {
                std::fill_n(begin(), max_size(), value);
                size_ = max_size();
            }
 
            inline bool empty() const noexcept
            {
                return (size_ == 0);
            }
 
            inline void push(const TType &value)
            {
                // Pop last element
                if (size_ == TSize)
                    pop_back();
 
                // Shift right
                for (int i = size_ - 1; i >= 0; i--)
                    array_[i + 1] = array_[i];
 
                array_[0] = value;
                size_++;
            }
 
            inline void pop_front()
            {
                // Shift left
                for (int i = 0; i < size_ - 1; i++)
                    array_[i] = array_[i + 1];
 
                size_--;
            }
 
            inline void pop_back()
            {
                if (size_ == 0)
                    return;
 
                size_--;
            }
 
            inline TType &front()
            {
                // TODO: Replace exception by StatusOr<TType>.
                if (size_ == 0)
                    throw std::out_of_range("ArrayStack has size 0.");
 
                return array_[0];
            }
 
            inline const TType &front() const
            {
                // TODO: Replace exception by StatusOr<TType>.
                if (size_ == 0)
                    throw std::out_of_range("ArrayStack has size 0.");
 
                return array_[0];
            }
 
            inline TType &back()
            {
                // TODO: Replace exception by StatusOr<TType>.
                if (size_ == 0)
                    throw std::out_of_range("ArrayStack has size 0.");
 
                return array_[size_ - 1];
            }
 
            inline const TType &back() const
            {
                // TODO: Replace exception by StatusOr<TType>.
                if (size_ == 0)
                    throw std::out_of_range("ArrayStack has size 0.");
 
                return array_[size_ - 1];
            }
 
            inline typename arrayType::iterator begin() noexcept
            {
                return array_.begin();
            }
 
            inline typename arrayType::const_iterator begin() const noexcept
            {
                return array_.begin();
            }
 
            inline typename arrayType::iterator end() noexcept
            {
                return array_.begin() + size_;
            }
 
            inline typename arrayType::const_iterator end() const noexcept
            {
                return array_.begin() + size_;
            }
 
            const arrayType &array() const noexcept
            {
                return array_;
            }
 
        protected:
            arrayType array_;
            size_t size_;
        };
    }
}
 
#endif //LODESTAR_ARRAYSTACK_HPP