Binder.hpp

[詳解]

 
 
#pragma once
 
#include "Exception.h"
 
namespace alt
{
    namespace skeleton
    {
        template <class T, class... Args>
        class Binder
        {
        public:
            Binder<T, Args...> ()
            {
                _value = nullptr;
            };
 
            Binder<T, Args...> (T* t)
            {
                _value = t;
            }
 
            virtual APIENTRY ~Binder ()
            {
                Delete ();
            };
 
            bool APIENTRY New (Args... args)
            {
                _value = new T (args...);
                return _value == nullptr ? false : true;
            };
 
            VOID APIENTRY Delete ()
            {
                delete _value;
                _value = nullptr;
            };
 
            T* APIENTRY Get () const
            {
                if (_value == nullptr)
                {
                    throw(alt::ex::RuntimeException ());
                }
 
                return _value;
            }
 
            T* APIENTRY operator -> () const
            {
                return Get ();
            }
 
            VOID APIENTRY Set (T* t)
            {
                if (_value != nullptr)
                {
                    delete _value;
                }
 
                _value = t;
            };
 
        private:
            Binder<T, Args...> (const Binder<T, Args...>&) = delete;
            VOID operator = (const Binder<T, Args...>&) = delete;
            T* _value;
        };
    }
}