FixedStack.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/aliases_int.hpp"
#include "shambase/assert.hpp"
#include <type_traits>
 
namespace shambase {
 
    template<class T, u32 stack_size>
    struct FixedStack {
 
        static_assert(
            std::is_trivially_destructible_v<T>,
            "FixedStack only supports trivially destructible types to avoid resource leaks.");
        static_assert(stack_size > 0, "FixedStack must have a size greater than 0.");
 
        T id_stack[stack_size];
        u32 stack_cursor;
 
        // Note that the stack itself is voluntarily not initialized
        // do not add it to the constructor otherwise we may have to pay for zero initialization
 
        inline constexpr FixedStack() : stack_cursor{stack_size} {}
 
        inline constexpr FixedStack(const T &val) : stack_cursor{stack_size - 1} {
            id_stack[stack_cursor] = val;
        }
 
        inline constexpr bool is_not_empty() const { return stack_cursor < stack_size; }
 
        inline constexpr bool empty() const { return stack_cursor == stack_size; }
 
        inline constexpr u32 size() const { return stack_size - stack_cursor; }
 
        inline void push(const T &val) {
 
            // FixedStack overflow: cannot push to a full stack.
            SHAM_ASSERT(stack_cursor > 0);
 
            stack_cursor--;
            id_stack[stack_cursor] = val;
        }
 
        inline T &top() {
            SHAM_ASSERT(is_not_empty());
            return id_stack[stack_cursor];
        }
 
        inline constexpr const T &top() const {
            SHAM_ASSERT(is_not_empty());
            return id_stack[stack_cursor];
        }
 
        inline constexpr void pop() {
 
            // FixedStack underflow: cannot pop from an empty stack.
            SHAM_ASSERT(is_not_empty());
 
            stack_cursor++;
        }
 
        [[nodiscard]]
        inline T pop_ret() {
            T val = top();
            pop();
            return val;
        }
    };
 
} // namespace shambase