Manager.h

Go to the documentation of this file.
00001 /*
00002 *
00003 *       This file contains template for simple object manager
00004 *
00005 *       Author:
00006 *                       Tomas Mrkvicka
00007 *                       xmrkvi03@stud.fit.vutbr.cz
00008 *
00009 */
00010 #include <vector>
00011 using namespace std;
00012 
00013 #include <windows.h>
00014 
00015 #ifndef _SIMPLEUNIT_MANAGER_HH_
00016 #define _SIMPLEUNIT_MANAGER_HH_
00017 
00018 namespace NSSimpleUnit
00019 {
00020 
00021 /**     Tato sablona reprezentuje manager pro dynamicky alokovane objekty.
00022 *       
00023 *       Manager muze obsahovat pouze jednoduche objekty, ktere neobsahuji reference na externi objekty apod.
00024 *       Objekty jsou vytvareny v manageru a pak vraceny aplikaci. Z toho duvodu musi byt objekty vytovritelne
00025 *       pres defaultni konstruktor a musi mit k dispozici operator delete (zadna metoda Release apod.).
00026 *
00027 *       Jakmile je objekt vracen z manageru do aplikace, prebira za nej aplikace odpovednost. Bud
00028 *       muze objekt vratit do manageru metodou PushItem() nebo znici objekt.
00029 */
00030 template <typename T>
00031 class TManager
00032 {
00033 //PUBLIC METHODS
00034 public:
00035                                         TManager(void);
00036                                         TManager(DWORD size);
00037                                         ~TManager( void );
00038 
00039         T*                              GetItem(void);
00040         void                    PushItem(T * item );
00041 
00042 //PUBLIC STATIC METHODS
00043 public:
00044         static DWORD    GetAllocCount(void);
00045 
00046 //PRIVATE FAKE METHODS
00047 private:
00048                                         TManager( const TManager & orig);       ///< falesny kopirovaci konstruktor
00049         void                    operator=( const TManager & orig );     ///< falesny prirazovaci operator
00050 
00051 //PRIVATE COMPONENTS
00052 private:
00053         vector<T*>              m_objects;              ///< vektor s ukazateli na objekty.
00054 
00055         static DWORD    ms_alloc_count; ///< celkovy pocet alokovanych objektu v manageru
00056 };
00057 //OK 2007-08-25 21:58:37 B04-315B\Tom
00058 
00059 /** Implicitni konstruktor.
00060 *
00061 *       Vytvori manager bez predalokovanych objektu
00062 */
00063 template <typename T>
00064 inline TManager<T>::TManager(void)
00065 {
00066 }
00067 
00068 /** Konstruktor. Vytvori zadany pocet objektu do vnitrniho pole.
00069 *
00070 *       \param  size    [in] pocet predalokovanych objektu
00071 */
00072 template <typename T>
00073 inline TManager<T>::TManager(DWORD size)
00074 {
00075         for ( DWORD i = 0; i < size ; i++ )
00076         {
00077                 ms_alloc_count++;
00078                 m_objects.push_back( new T );
00079         }
00080 }
00081 //OK 2007-08-25 21:59:32 B04-315B\Tom
00082 
00083 /** Destruktor.
00084 *
00085 *       Automaticky znici vsechny objekty alokovane v manageru v dobe volani.
00086 */
00087 template <typename T>
00088 inline TManager<T>::~TManager(void)
00089 {
00090         while ( ! m_objects.empty() )
00091         {
00092                 T * ptr = m_objects.back();
00093                 delete ptr;
00094                 m_objects.pop_back();
00095         }
00096 }
00097 //OK 2007-08-25 21:59:39 B04-315B\Tom
00098 
00099 /** Vrati novy objekt.
00100 *
00101 *       Pokud neni dalsi objekt k dispozici pak je novy alokovan.
00102 *
00103 *       Metoda zaroven odstrani vraceny objekt z manageru a postarat se o nej musi
00104 *       aplikace.
00105 */
00106 template <typename T>
00107 inline T* TManager<T>::GetItem(void)
00108 {
00109         if ( ! m_objects.empty() )
00110         {
00111                 //mame naalokovany objekt
00112                 T * ptr = m_objects.back();
00113                 m_objects.pop_back();
00114 
00115                 return ptr;
00116         }
00117         else
00118         {
00119                 //nemame uz dalsi objekt - vytvorime novy
00120                 ms_alloc_count++;
00121                 return new T;
00122         }
00123 }
00124 //OK 2007-08-25 21:59:54 B04-315B\Tom
00125 
00126 /** Pomoci teto metody lze vratit drive ziskany objekt zpet do manageru.
00127 *
00128 *       \param  item    [in] dynamicky alokovany objekt drive ziskany z tohoto manazeru
00129 */
00130 template <typename T>
00131 inline void TManager<T>::PushItem( T * item  )
00132 {
00133         m_objects.push_back( item );
00134 }
00135 //OK 2007-08-25 22:00:04 B04-315B\Tom
00136 
00137 /** Vrati celkovy pocet alokaci provedenych v managerech tohoto typu.
00138 */
00139 template <typename T>
00140 inline DWORD TManager<T>::GetAllocCount(void)
00141 {
00142         return ms_alloc_count;
00143 }
00144 //OK 2007-08-25 22:00:14 B04-315B\Tom
00145 
00146 }; //END of namespace NSSimpleUnit
00147 using namespace NSSimpleUnit;
00148 
00149 #endif

Generated on Sat Nov 17 16:23:26 2007 for Image Processing Pipeline by  doxygen 1.4.6-NO