Stack.h

Go to the documentation of this file.

 
#pragma once
#include "common/Platform.h"
#include "common/Noncopyable.h"
#include "common/OutputStream.h"
#include <memory>
 
namespace mana
{
    class Actor;
 
    class Stack final : Noncopyable
    {
    public:
        Stack();
        Stack(const Stack&) = delete;
        Stack(Stack&&) noexcept = delete;
        Stack& operator=(const Stack&) = delete;
        Stack& operator=(Stack&&) noexcept = delete;
        ~Stack() = default;
 
        void Serialize(const std::shared_ptr<OutputStream>& stream) const;
        void Deserialize(const std::shared_ptr<OutputStream>& stream);
 
        void Clear();
 
        void Duplicate();
 
        void Remove(const address_t size);
 
        template<typename T>
        void Push(T value);
 
        void Push(const void* buffer, const address_t size);
 
        template<typename T>
        T Pop();
 
        void PopData(void* buffer, const address_t size);
 
        template<typename T>
        T Get(const address_t index) const;
 
        void* GetAddress(const address_t index) const;
 
        template<typename T>
        void Set(const address_t index, T value);
 
        address_t GetSize() const;
 
        void SetSize(const address_t size);
 
        bool operator==(const Stack& other) const;
    
    private:
        static address_t GetAlignmentSize(const address_t size);
        void AllocateBegin(const address_t gainSize);
        void AllocateEnd(const address_t gainSize);
        void Deallocate(const address_t releaseSize);
 
    private:
        union Buffer
        {
            Actor* mActorPointer;
            const char* mStringPointer;
            void* mVoidPointer;
            int_t mInteger;
            float_t mFloat;
            bool mBool;
 
            explicit operator Actor*() const { return mActorPointer; }
            explicit operator const char*() const { return mStringPointer; }
            explicit operator void*() const { return mVoidPointer; }
            explicit operator int32_t() const { return static_cast<int32_t>(mInteger); }
            explicit operator int64_t() const { return static_cast<int64_t>(mInteger); }
            explicit operator float() const { return static_cast<float>(mFloat); }
            explicit operator double() const { return static_cast<double>(mFloat); }
            explicit operator bool() const { return mBool; }
 
            void Set(Actor* actorPointer) { mActorPointer = actorPointer; }
            void Set(const char* stringPointer) { mStringPointer = stringPointer; }
            void Set(void* voidPointer) { mVoidPointer = voidPointer; }
            void Set(const int32_t value) { mInteger = static_cast<int_t>(value); }
            void Set(const int64_t value) { mInteger = static_cast<int_t>(value); }
            void Set(const float value) { mFloat = static_cast<float_t>(value); }
            void Set(const double value) { mFloat = static_cast<float_t>(value); }
            void Set(bool const value) { mBool = value; }
        };
        std::unique_ptr<Buffer, decltype(&std::free)> mBuffer;
        address_t mAllocatedSize = 0;
        address_t mUsedSize = 0;
    };
}
 
#include "Stack.inl"