MemoryChunk.h

#pragma once

#include "swCommonLib/Common//TypesDefinitions.h"

#include <vector>

class MemoryChunk
{
private:
protected:
    int8*           m_memory;
    uint32          m_size;
public:
    MemoryChunk()
        : m_memory( nullptr ),
        m_size( 0 )
    {}

    MemoryChunk( int8*&& dataPointer, uint32 dataSize )
        :   m_memory( dataPointer ),
            m_size( dataSize )
    {}
    MemoryChunk( uint32 dataSize )
        :   m_memory( new int8[dataSize] ),
            m_size( dataSize )
    {}

    //template<typename Type>
    //MemoryChunk( std::vector<Type>&& vector )
    //{
    //  //vector.
    //}

    ~MemoryChunk()
    {
        delete[] m_memory;
    }

    MemoryChunk& operator=( const MemoryChunk& ) = delete;      
    MemoryChunk( const MemoryChunk& ) = delete;                 

    MemoryChunk( MemoryChunk&& chunk )              
    {
        m_memory = chunk.m_memory;
        m_size = chunk.m_size;
        chunk.m_memory = nullptr;
        chunk.m_size = 0;
    }

    MemoryChunk& operator=( MemoryChunk&& chunk )   
    {
        if( &chunk != this )
        {
            delete[] m_memory;
            m_memory = chunk.m_memory;
            m_size = chunk.m_size;
            chunk.m_size = 0;
            chunk.m_memory = nullptr;
        }
        return *this;
    }

    template<typename Type>
    inline Type*            GetMemory       ()      { return reinterpret_cast<Type*>( m_memory ); }

    template<typename Type>
    inline const Type*      GetMemory       () const    { return reinterpret_cast<Type*>( m_memory ); }

    inline uint32           GetMemorySize   () const    { return m_size; }          

    template<typename Type>
    inline Type&            Get             ( uint32 index )
    {   return reinterpret_cast<Type*>( m_memory )[ index ];        }

    template<typename Type>
    inline uint32           Count           ()
    {   return GetMemorySize() / sizeof( Type );    }   

    inline bool             IsNull          () const { return !m_memory; }      

    inline void             MemoryCopy      ( const int8* dataPointer, uint32 dataSize )
    {
        if( m_memory )
            delete[] m_memory;
        
        m_memory = new int8[ dataSize ];
        memcpy( m_memory, dataPointer, dataSize );
        m_size = dataSize;
    }

};