Freight.hpp

[詳解]

 
 
#pragma once
 
#include "HeapMemory.h"
 
namespace alt
{
    namespace skeleton
    {
        template<class T>
        class Freight
        {
        public:
            Freight<T> ()
            {
                _memory = new alt::BasicMemory ();
                _lpData = NULL;
                _size = 0;
            };
 
            Freight<T> (IMemory* memory)
            {
                if (memory == NULL)
                    _memory = new alt::BasicMemory ();
                else
                    _memory = memory;
                _lpData = NULL;
                _size = 0;
            };
 
            Freight<T> (T* lpData, size_t size, IMemory* memory = NULL)
                :Freight (memory)
            {
                SetData (lpData, size);
            };
 
            Freight<T> (const Freight<T>& base)
            {
                if (dynamic_cast<alt::BasicMemory*>(base._memory))
                    _memory = new alt::BasicMemory ();
                else
                    _memory = base._memory;
                _lpData = NULL;
                _size = 0;
                SetData (base._lpData, base._size);
            };
 
            APIENTRY ~Freight ()
            {
                Clear ();
                auto basicMemory = dynamic_cast<alt::BasicMemory*>(_memory);
                if (basicMemory)
                {
                    delete basicMemory;
                }
                _memory = NULL;
            };
 
            VOID APIENTRY SetData (T* lpData, size_t size)
            {
                New (size);
                // ここで正確に情報をコピーできるのは、
                // charやunsigned char などのプリミティブな
                // 型だけになる。コンストラクタやデストラクタを
                // 持つものは、対応不可。operator = ()も動かない。
                CopyMemory (_lpData, lpData, size * sizeof (T));
                _size = size;
            };
 
            VOID APIENTRY New (size_t size)
            {
                Clear ();
                _lpData = static_cast<T*>(_memory->Allocate (sizeof (T) * size));
                _size = size;
            };
 
            T* APIENTRY GetData () const { return _lpData; };
 
            size_t APIENTRY GetSize () const { return _size; }
 
            VOID APIENTRY Clear ()
            {
                if (_lpData != NULL)
                {
                    _memory->Free (_lpData);
                    _lpData = NULL;
                    _size = 0;
                }
            };
 
            VOID APIENTRY operator = (const Freight<T>& base)
            {
                if (dynamic_cast<alt::BasicMemory*>(base._memory))
                    _memory = new alt::BasicMemory ();
                else
                    _memory = base._memory;
                SetData (base._lpData, base._size);
            };
 
        private:
            IMemory* _memory;
            T* _lpData;
            size_t _size;
        };
    }
}