stack.h

 
#pragma once
 
#include <array>
 
#include "../defines.h" //STD_SAFE_AT
 
namespace Ponca
{
 
    template <class T, int N>
    class Stack
    {
    public:
        using ValueType = T;
 
        PONCA_MULTIARCH inline Stack();
 
        PONCA_MULTIARCH inline const T& top() const;
        PONCA_MULTIARCH inline T& top();
 
        PONCA_MULTIARCH inline bool empty() const;
        PONCA_MULTIARCH inline int size() const;
 
        PONCA_MULTIARCH inline void push(const T& value);
 
        PONCA_MULTIARCH inline void push();
        PONCA_MULTIARCH inline void pop();
        PONCA_MULTIARCH inline void clear();
 
    protected:
        int m_size;
        std::array<T, N> m_data;
    };
 
 
    template <class T, int N>
    Stack<T, N>::Stack() : m_size(0), m_data()
    {
    }
 
    template <class T, int N>
    const T& Stack<T, N>::top() const
    {
        return STD_SAFE_AT(m_data, m_size - 1);
    }
 
    template <class T, int N>
    T& Stack<T, N>::top()
    {
        return STD_SAFE_AT(m_data, m_size - 1);
    }
 
    template <class T, int N>
    bool Stack<T, N>::empty() const
    {
        return m_size == 0;
    }
 
    template <class T, int N>
    int Stack<T, N>::size() const
    {
        return m_size;
    }
 
    template <class T, int N>
    void Stack<T, N>::push(const T& value)
    {
        STD_SAFE_AT(m_data, m_size) = value;
        ++m_size;
    }
 
    template <class T, int N>
    void Stack<T, N>::push()
    {
        ++m_size;
    }
 
    template <class T, int N>
    void Stack<T, N>::pop()
    {
        --m_size;
    }
 
    template <class T, int N>
    void Stack<T, N>::clear()
    {
        m_size = 0;
    }
 
} // namespace Ponca