#pragma once

#include <memory>
#include <optional>
#include <utility>

template<typename T> class stack
{
public:
    ~stack()
    {
        while (head) head = std::move(head->next);
    }

    void push(const T &t) { push_impl(t); }

    void push(T &&t) { push_impl(std::move(t)); }

    std::optional<T> pop()
    {
        std::optional<T> ret = std::nullopt;
        atomic_noexcept
        {
            if (head)
            {
                ret = std::move(head->data);
                head = std::move(head->next);
            }
        }
        return ret;
    }

private:
    template<typename U> void push_impl(U &&u)
    {
        auto p = std::make_unique<node>(nullptr, std::forward<U>(u));
        atomic_noexcept
        {
            p->next = std::move(head);
            head = std::move(p);
        }
    }

    struct node
    {
        std::unique_ptr<node> next;
        T data;
    };

    std::unique_ptr<node> head = nullptr;
};