mn_stack.hpp

Go to the documentation of this file.

// *** ADDED BY HEADER FIXUP ***
#include <cstdlib>
// *** END ***
/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2020 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread Library is distributed in the hope that it will be useful, but
*WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef _MINLIB_STAK_H_
#define _MINLIB_STAK_H_
 
#include "../mn_config.hpp"
#include "../mn_error.hpp"
 
#include <stdio.h>
#include <malloc.h>
#include <stdint.h>
 
namespace mn {
    namespace container {
        template<typename TType>
        class basic_stack {
        public:
            using basic_type_t = TType;
 
            explicit basic_stack(size_t nSize) {
                internal_create(nSize, (basic_type_t*)malloc( size_of(basic_type_t) * nSize), 0 ); }
 
            basic_stack(size_t nSize, basic_type_t* addr) {
                internal_create(nSize, addr, 0); }
 
            basic_stack(size_t nSize, basic_type_t* addr, int offset) {
                internal_create(nSize, addr, offset); }
 
            int push(basic_type_t item) {
                int _ret = ERR_MNTHREAD_UNKN;
 
                if(m_iCurrent < m_iLast - 1) {
                    m_iCurrent++;
                    m_ulAdrr[m_iCurrent] = item;
                    _ret = NO_ERROR;
                }
                return _ret;
            }
            int pop(basic_type_t* item) {
                if(item == NULL) return ERR_NULL;
 
                if(count() > 0 ) {
                    basic_type_t x = m_ulAdrr[m_iCurrent];
                    m_iCurrent--;
                    *item = x;
                    return NO_ERROR;
                }
                return ERR_MNTHREAD_UNKN;
            }
            int peek(basic_type_t* item) {
                if(item == NULL) return ERR_NULL;
 
                if(count() > 0 ) {
                    basic_type_t x = m_ulAdrr[m_iCurrent];
                    *item = x;
                    return NO_ERROR;
                }
                return ERR_MNTHREAD_UNKN;
            }
            void reset() {
                internal_reset();
            }
 
            int count()     { return m_iCurrent + 1; }
            int size()      { return m_ulSize; }
 
            bool is_empty() { return (m_iCurrent == -1); }
            bool is_full()  { return (m_iCurrent == (m_iLast - 1) ); }
 
            int get_left()  { return m_ulSize - (m_iCurrent + 1); }
        private:
            void internal_create(size_t nSize, basic_type_t* addr, int offset) {
                m_ulAdrr = (addr);
                m_ulSize = (nSize - offset);
 
                m_iFirst = (offset - 1);
                m_iCurrent = (m_iFirst);
                m_iLast = (nSize);
            }
            void internal_reset() {
                while(!is_empty())
                    pop();
                m_iCurrent = m_iFirst;
            }
        private:
            basic_type_t *m_ulAdrr;
            size_t m_ulSize;
            size_t m_iFirst;
            size_t m_iLast;
            size_t m_iCurrent;
        };
 
        using stack_t = basic_stack<MN_THREAD_CONFIG_STACK_TYPE>;
 
        using uint8_stack_t  = basic_stack<uint8_t>;
        using uint16_stack_t = basic_stack<uint16_t>;
        using uint32_stack_t = basic_stack<uint32_t>;
        using uint64_stack_t = basic_stack<uint64_t>;
 
        using int8_stack_t  = basic_stack<int8_t>;
        using int16_stack_t = basic_stack<int16_t>;
        using int32_stack_t = basic_stack<int32_t>;
        using int64_stack_t = basic_stack<int64_t>;
 
        using string_stack_t = basic_stack<const char*>;
        using float_stack_t = basic_stack<float>;
    }
}
 
#endif