stack.hpp

//
// スタック
//
 
#ifndef _COLLECTION2_STACK_H_
#define _COLLECTION2_STACK_H_
 
#include <stddef.h>
 
#include "common.hpp"
 
namespace collection2 {
 
template <typename Element, typename Size = size_t>
class Stack {
   private:
    Element* const internalData;
 
    Size internalDataSize;
 
    Size sp = 0;
 
   public:
    Stack(Element* const data, const Size& dataSize);
 
    Stack(const Stack&) = delete;
    Stack& operator=(const Stack&) = delete;
 
    ~Stack() = default;
 
    OperationResult push(const Element& data);
 
    OperationResult pop(Element* const data);
 
    Size capacity() const {
        return internalDataSize;
    }
 
    Size amount() const {
        return sp;
    }
 
    bool hasSpace() const {
        return sp < internalDataSize;
    }
 
    bool isEmpty() const {
        return sp == 0;
    }
};
 
template <typename Element, typename Size>
Stack<Element, Size>::Stack(Element* const data, const Size& dataSize) : internalData(data), internalDataSize(dataSize){};
 
template <typename Element, typename Size>
OperationResult Stack<Element, Size>::push(const Element& data) {
    // スタックがいっぱいなら戻る
    if (!hasSpace()) {
        return OperationResult::Overflow;
    }
 
    // spの位置にデータを書き込んで進める
    *(internalData + sp) = data;
    sp++;
 
    return OperationResult::Success;
}
 
template <typename Element, typename Size>
OperationResult Stack<Element, Size>::pop(Element* const data) {
    // スタックが空なら戻る
    if (isEmpty()) {
        return OperationResult::Empty;
    }
 
    // spを減らしてデータを読み出す
    sp--;
    *data = *(internalData + sp);
    return OperationResult::Success;
}
 
}  // namespace collection2
 
#endif