array_stack.hpp

Go to the documentation of this file.

//===- include/pstore/core/array_stack.hpp ----------------*- mode: C++ -*-===//
//*                                   _             _     *
//*   __ _ _ __ _ __ __ _ _   _   ___| |_ __ _  ___| | __ *
//*  / _` | '__| '__/ _` | | | | / __| __/ _` |/ __| |/ / *
//* | (_| | |  | | | (_| | |_| | \__ \ || (_| | (__|   <  *
//*  \__,_|_|  |_|  \__,_|\__, | |___/\__\__,_|\___|_|\_\ *
//*                       |___/                           *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_CORE_ARRAY_STACK_HPP
#define PSTORE_CORE_ARRAY_STACK_HPP

#include <array>
#include <cstdlib>

#include "pstore/support/assert.hpp"

namespace pstore {


    template <class Ty, std::size_t Size>
    class array_stack {
    public:
        using container_type = std::array<Ty, Size>;
        using value_type = typename container_type::value_type;
        using reference = typename container_type::reference;
        using const_reference = typename container_type::const_reference;
        using size_type = typename container_type::size_type;

        array_stack () = default;

        bool operator== (array_stack const & other) const {
            return elements_ == other.elements_ && std::equal (begin (), end (), other.begin ());
        }
        bool operator!= (array_stack const & other) const { return !operator== (other); }

        typename container_type::const_iterator begin () const { return std::begin (c_); }
        typename container_type::const_iterator end () const { return std::begin (c_) + elements_; }


        constexpr bool empty () const noexcept { return elements_ == 0; }

        constexpr size_type size () const noexcept { return elements_; }

        constexpr size_t max_size () const noexcept { return Size; }



        reference top () noexcept {
            PSTORE_ASSERT (elements_ > 0);
            return c_[elements_ - 1];
        }
        const_reference top () const noexcept {
            PSTORE_ASSERT (elements_ > 0);
            return c_[elements_ - 1];
        }


        void push (value_type const & value) {
            PSTORE_ASSERT (elements_ < Size);
            c_[elements_++] = value;
        }
        void push (value_type && value) {
            PSTORE_ASSERT (elements_ < Size);
            c_[elements_++] = std::move (value);
        }

        void pop () {
            PSTORE_ASSERT (elements_ > 0);
            --elements_;
        }

    private:
        container_type c_;
        std::size_t elements_{0};
    };
} // namespace pstore

#endif // PSTORE_CORE_ARRAY_STACK_HPP