• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

spl/LazyLoadPtr.h

00001 /*
00002  *   This file is part of the Standard Portable Library (SPL).
00003  *
00004  *   SPL is free software: you can redistribute it and/or modify
00005  *   it under the terms of the GNU General Public License as published by
00006  *   the Free Software Foundation, either version 3 of the License, or
00007  *   (at your option) any later version.
00008  *
00009  *   SPL is distributed in the hope that it will be useful,
00010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *   GNU General Public License for more details.
00013  *
00014  *   You should have received a copy of the GNU General Public License
00015  *   along with SPL.  If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 #ifndef _createonaccessptr_h
00018 #define _createonaccessptr_h
00019 
00020 #include <spl/Memory.h>
00021 
00028 template <class T> class LazyLoadPtr : public IMemoryValidate
00029 {
00030 private:
00031         T* m_ptr;
00032 
00033         void Create()
00034         {
00035                 if (NULL == m_ptr) 
00036                 {
00037                         m_ptr = new T();
00038                 }
00039         }
00040 
00041         LazyLoadPtr(const LazyLoadPtr&) 
00042         {
00043         }
00044 
00045         LazyLoadPtr& operator =(const LazyLoadPtr&) 
00046         {
00047         }
00048 
00049 public:
00050         LazyLoadPtr()
00051         : m_ptr(NULL) 
00052         {
00053         }
00054 
00055         ~LazyLoadPtr()
00056         {
00057                 if (NULL != m_ptr)
00058                 {
00059                         delete m_ptr;
00060                 }
00061         }
00062 
00063         T& operator*()
00064         {
00065                 Create(); 
00066                 return *m_ptr;
00067         }
00068 
00069         T* operator->()
00070         {
00071                 Create(); 
00072                 return m_ptr;
00073         }
00074 
00075         T* Get()
00076         {
00077                 Create(); 
00078                 return m_ptr;
00079         }
00080         
00081 #ifdef DEBUG
00082         virtual void ValidateMem() const
00083         {
00084                 if (NULL != m_ptr)
00085                 {
00086                         ValidateType(m_ptr);
00087                 }
00088         }
00089 
00090         virtual void CheckMem() const
00091         {
00092                 if (NULL != m_ptr)
00093                 {
00094                         ValidateType(m_ptr);
00095                 }
00096         }
00097 #endif
00098 };
00099 
00102 #endif