CPP-Stack/include/stack.h

#ifndef STACK_H
#define STACK_H

#include <cstdint>
#include <expected>
#include <format>
#include <new>

#define DEFAULT_STACK_SIZE 4

enum class StackErr {
    ok,
    bad_alloc,
    empty,
};

template<typename T>
requires std::formattable<T, char>
class Stack {
private:
    uint64_t len;
    uint64_t cap;
    T *data;

public:
    Stack();
    ~Stack();

    std::expected<T, StackErr> pop();

    std::expected<T, StackErr> peek();

    StackErr push(T val);

    void print();
};

template <typename T>
requires std::formattable<T, char>
Stack<T>::Stack() {
    Stack<T> new_stack;
    new_stack.data = new T[DEFAULT_STACK_SIZE];
    new_stack.cap = 0;
    new_stack.len = 0;
    return new_stack;
}

template <typename T>
requires std::formattable<T, char>
Stack<T>::~Stack() {
    delete[] this->data;
}

template <typename T>
requires std::formattable<T, char>
StackErr Stack<T>::push(T value) {
    // If not enough space allocate more space
    if (this->len >= this->cap) {
        uint64_t new_capacity = this->cap * 2;
        T *tmp;

        try {
            tmp = new T[new_capacity];
        } catch (const std::bad_alloc& e) {
            return StackErr::bad_alloc;
        }

        for (int i = 0; i < this->len; i++) {
            tmp[i] = this->data[i];
        }

        delete[] this->data;
        this->data = tmp;
    }

    this->data[this->len] = value;
    this->len++;

    return StackErr::ok;
}

template <typename T>
requires std::formattable<T, char>
std::expected<T, StackErr> Stack<T>::pop() {
    if (this->len == 0) {
        return std::unexpected(StackErr::empty);
    }

    T return_val = this->data[this->len - 1];

    if (this->cap / 4 > this->len) {
        uint64_t new_capacity = this->cap / 2;
        T *tmp;

        try {
            tmp = new T[new_capacity];
        } catch (const std::bad_alloc& e) {
            return std::unexpected(StackErr::bad_alloc);
        }

        for (int i = 0; i < this->len; i++) {
            tmp[i] = this->data[i];
        }

        delete[] this->data;
        this->data = tmp;
    }

    return std::expected(return_val);
}

template <typename T>
requires std::formattable<T, char>
std::expected<T, StackErr> Stack<T>::peek() {
    if (this->len == 0) {
        return std::unexpected(StackErr::empty);
    }

    return std::expected(this->data[this->len - 1]);
}

#endif // !ST