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;
 
    inline Stack();
 
    inline const T& top() const;
    inline       T& top();
 
    inline bool empty() const;
    inline int  size() const;
 
    inline void push(const T& value);
 
    inline void push();
    inline void pop();
    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