Simple_integer.h

Go to the documentation of this file.
00001 /*
00002 *       This file contains class that represents working class inside
00003 *       TSimpleUnit and returns 
00004 *
00005 *               INTEGER 
00006 *
00007 *       value. Returned class
00008 *       is derived from 
00009 *
00010 *               TUnitRetType_integer 
00011 *
00012 *       class.
00013 *
00014 *       Author:
00015 *                       Tomas Mrkvicka
00016 *                       xmrkvi03@stud.fit.vutbr.cz
00017 *
00018 */
00019 
00020 #include <deque>
00021 using namespace std;
00022 
00023 namespace NSSimpleUnit
00024 {
00025         class TUnitRetType_integer_implemented;
00026         class TSimpleUnitProcessingInterface_integer;
00027 };
00028 
00029 #ifndef _SIMPLEUNIT_SIMPLE_INTEGER_HH_
00030 #define _SIMPLEUNIT_SIMPLE_INTEGER_HH_
00031 
00032 #include "pipeline/SimpleUnit.h"
00033 #include "simpleunit/Manager.h"
00034 
00035 namespace NSSimpleUnit
00036 {
00037 
00038 ////////////////////////////////////////////////////////////////////////////////
00039 ////////////////////////////////////////////////////////////////////////////////
00040 ////////////////////////////////////////////////////////////////////////////////
00041 // TUnitRetType_integer_implemented
00042 
00043 /** Tato trida reprezentuje navratovy typ reprezentujici cele cislo.
00044 *
00045 *       Jedina pouzitelna metoda pro vypocetni jednotku je metoda SetValue(int), ktera
00046 *       nastavi novy vysledek do objektu.
00047 *
00048 *       Ostatni nevirtualni metody jsou nepodstatne.
00049 *
00050 *       Objekty z teto tridy jsou vytvarenu v manageru objektu typu TManager<TUnitRetType_integer_implemented>
00051 *       ktery je umisten primo v jednotce typu TSimpleUnitProcessingInterface_integer.
00052 *
00053 *       Po vytvoreni objektu je do nej ulozena informace o jednotce (ukazatel) - pri uvolnovani objektu
00054 *       je tento do jednotky vracen.
00055 *
00056 *       JE VZDY NUTNE REIMPLEMENTOVAT VSECHNY VIRTUALNI METODY Z BAZOVE TRIDY!!!
00057 */
00058 class TUnitRetType_integer_implemented : public TUnitRetType_integer
00059 {
00060 friend TManager<TUnitRetType_integer_implemented>;
00061 friend TSimpleUnitProcessingInterface_integer;
00062 
00063 //PUBLIC OVERRIDEN METHODS
00064 public:
00065         virtual void                    Release(void);
00066         virtual int                             GetValue(void);
00067 
00068 //PUBLIC METHODS
00069 public:
00070         void                                    SetValue( int value );
00071 
00072 //PRIVATE METHODS
00073 private:
00074                                                         TUnitRetType_integer_implemented(void);
00075                                                         ~TUnitRetType_integer_implemented(void);
00076 
00077         void                                    AddRefs(void);
00078         void                                    Reset(void);
00079         void                                    SetParent( TSimpleUnitProcessingInterface_integer * parent);
00080 
00081 //PRIVATE FAKE METHODS
00082 private:
00083                                                         TUnitRetType_integer_implemented( const TUnitRetType_integer_implemented & orig);       ///< falesny kopirovaci konstruktor
00084         void                                    operator=(  const TUnitRetType_integer_implemented & orig);                                                     ///< falesny prirazovaci operator
00085 
00086 //PRIVATE COMPONENTS
00087 private:
00088         DWORD                                                                           m_refs;         ///< pocet referenci na objekt
00089         int                                                                                     m_value;        ///< vlastni ulozena hodnota
00090 
00091         TCriticalSection                                                        m_cs;           ///< synchronizace pro pocitani referenci
00092 
00093         TSimpleUnitProcessingInterface_integer*         m_parent;       ///< jednotka kde byl objekt vytvoren
00094                                                                                                                         ///< a kam ma byt vracen
00095 };
00096 //OK 2007-08-25 23:47:53 B04-315B\Tom
00097 
00098 /** Virtualni metoda vracejici hodnotu ulozenou v tomto objektu.
00099 */
00100 inline int TUnitRetType_integer_implemented::GetValue(void)
00101 {
00102         return m_value;
00103 }
00104 //OK 2007-08-25 23:51:18 B04-315B\Tom
00105 
00106 /** Soukromy konstruktor.
00107 *
00108 *       Vytvori objekt s jednou referenci a hodnotou 0.
00109 *
00110 *       METODA JE VOLANA Z MANAGERU TECHTO OBJEKTU VE VYPOCETNI JEDNOTCE DEFINOVANE NIZE.
00111 */
00112 inline TUnitRetType_integer_implemented::TUnitRetType_integer_implemented(void)
00113 {
00114         m_refs  = 1;
00115         m_value = 0;
00116 }
00117 //OK 2007-08-25 23:51:20 B04-315B\Tom
00118 
00119 /** Soukromy destruktor.
00120 *
00121 *       METODA JE VOLANA Z MANAGERU TECHTO OBJEKTU VE VYPOCETNI JEDNOTCE DEFINOVANE NIZE.
00122 */
00123 inline TUnitRetType_integer_implemented::~TUnitRetType_integer_implemented(void)
00124 {
00125         //empty
00126 }
00127 //OK 2007-08-25 23:51:21 B04-315B\Tom
00128 
00129 /** Nastavi novou hodnotu do tohoto objektu.
00130 *
00131 *       Tato metoda by mela byt pouzita v ramci tridy TSimpleUnitProcessingInterface_integer
00132 *       v metode ProcessFrame, kdy objekt jeste neni zarazen do seznamu vysledku a tedy
00133 *       nad nim pracuje pouze jedno vlakno.
00134 *
00135 *       V metode ProcessFrame je ziskan vysledek, od objektu typu TSimpleUnitProcessingInterface_integer
00136 *       je ziskan novy objekt typu TUnitRetType_integer_implemented pres metodu GetObject() a do tohoto
00137 *       objektu je ulzena hodnota pres tuto metody SetValue().
00138 *
00139 *       \param  value   [in] nova hodnota
00140 */
00141 inline void TUnitRetType_integer_implemented::SetValue( int value )
00142 {
00143         m_value = value;
00144 }
00145 //OK 2007-08-25 23:51:23 B04-315B\Tom
00146 
00147 /** Pridani reference na objekt.
00148 */
00149 inline void TUnitRetType_integer_implemented::AddRefs(void)
00150 {
00151         m_cs.Enter();
00152                 m_refs++;
00153         m_cs.Leave();
00154 }
00155 //OK 2007-08-25 23:51:26 B04-315B\Tom
00156 
00157 /** Tato metoda inicializuje zadany objekt do podoby po vytvoreni.
00158 *
00159 *       Metoda by mela byt volana v manageru objektu pokud byl uz objekt
00160 *       drive pouzit. To znamena, ze objekt je pri zavolani drzen pouze jednim vlaknem
00161 *       a tedy neni potreba synchronizace.
00162 */
00163 inline void TUnitRetType_integer_implemented::Reset(void)
00164 {
00165         m_refs  = 1;
00166         m_value = 0;
00167 }
00168 //OK 2007-08-25 23:51:28 B04-315B\Tom
00169 
00170 /** Nastaveni rodicovske jednotky pro tento objekt.
00171 *
00172 *       Metoda je volana v manageru objektu zadane jednotky a tedy k ni pristupuje pouze
00173 *       jedno vlakno.
00174 *
00175 *       \param  parent  [in] rodicovska jednotka, ktera objekt vlastni a do ktere by mel byt vracen
00176 */
00177 inline void 
00178 TUnitRetType_integer_implemented::SetParent( TSimpleUnitProcessingInterface_integer * parent)
00179 {
00180         m_parent = parent;
00181 }
00182 //OK 2007-08-25 23:51:30 B04-315B\Tom
00183 
00184 // TUnitRetType_integer_implemented
00185 ////////////////////////////////////////////////////////////////////////////////
00186 ////////////////////////////////////////////////////////////////////////////////
00187 ////////////////////////////////////////////////////////////////////////////////
00188 // TSimpleUnitProcessingInterface_integer
00189 
00190 /** Tato jednotka vraci hodnoty typu INTEGER.
00191 *
00192 *       ODVOZENA TRIDA MUSI REIMPLEMENTOVAT METODU PROCESSFRAME()!!!
00193 */
00194 class TSimpleUnitProcessingInterface_integer : public TSimpleUnitProcessingInterface
00195 {
00196 friend TUnitRetType_integer_implemented;
00197 
00198 //PUBLIC OVERRIDEN METHODS
00199 public:
00200         virtual void                                            ProcessFrame( const TFrame * frame ) = 0;
00201 
00202         virtual                                                         ~TSimpleUnitProcessingInterface_integer(void);
00203         virtual EnumUnitType                            GetType(void) const { return ENUM_UNITTYPE_INTEGER; };
00204         virtual TUnitRetTypeInterface*          GetResult( DWORD id );
00205 
00206 //PUBLIC METHODS
00207 public:
00208                                                                                 TSimpleUnitProcessingInterface_integer(void);
00209 
00210 //PROTECTED METHODS
00211 protected:
00212         void                                                            AddResult( DWORD id, TUnitRetType_integer_implemented * res );
00213 
00214         TUnitRetType_integer_implemented*       GetObject(void);
00215         void                                                            ReturnObject( TUnitRetType_integer_implemented * object );
00216 
00217 //PROTECTED FAKE METHODS
00218 protected:
00219                                                                                 TSimpleUnitProcessingInterface_integer( const TSimpleUnitProcessingInterface_integer & orig);   ///< falesny kopirovaci konstruktor
00220         void                                                            operator=( const TSimpleUnitProcessingInterface_integer & orig);                                                                ///< falesny prirazovaci operator
00221 
00222 //PROTECTED COMPONENTS
00223 protected:
00224         static const DWORD sc_memory = 10;      ///< maximalni pocet vysledku, ktere si trida pamatuje
00225 
00226 //PRIVATE COMPONENTS
00227 private:
00228         deque<TUnitRetType_integer_implemented*>        m_results;              ///< posledni vysledky
00229         deque<DWORD>                                                            m_resultsID;    ///< identifikatory k vysledkum
00230                                                                                                                                 ///< identifikator urcuje ID snimku
00231                                                                                                                                 ///< ktereho se vysledek tyka
00232 
00233         TManager<TUnitRetType_integer_implemented>      m_objects;              ///< manager s objekty, neni je nutne
00234                                                                                                                                 ///< neustale alokovat
00235 
00236         TCriticalSection                                                        m_cs_res;               ///< synchronizace pristupu
00237                                                                                                                                 ///< k vysledkum        
00238         TCriticalSection                                                        m_cs_manager;   ///< synchronizace pristupu k manageru
00239 };
00240 //OK 2007-08-26 00:00:15 B04-315B\Tom
00241 
00242 /** Konstruktor.
00243 */
00244 inline TSimpleUnitProcessingInterface_integer::TSimpleUnitProcessingInterface_integer(void)
00245 {
00246         //empty
00247 }
00248 //OK 2007-08-26 00:00:17 B04-315B\Tom
00249 
00250 /** Virtualni destruktor.
00251 *
00252 *       Smi byt volan v okamziku kdyz uz neexistuji zadne reference na vysledky teto jednotky!!!
00253 */
00254 inline TSimpleUnitProcessingInterface_integer::~TSimpleUnitProcessingInterface_integer(void)
00255 {
00256         //odstranime vsechny vysledky
00257         while ( ! m_results.empty() )
00258         {
00259                 //muzeme pouzit operator delete, protoze na vysledek uz v aplikaci nejsou reference
00260                 //metoda Release() by vysledek pouze vratila do manageru
00261                 TUnitRetType_integer_implemented * ptr = m_results.front();
00262                 m_results.pop_front();
00263                 delete ptr;
00264         }
00265 }
00266 //OK 2007-08-26 00:00:19 B04-315B\Tom
00267 
00268 /** Ziskani vysledku ze snimku s pozadovanym ID.
00269 *
00270 *       \param  id              [in] identifikator pozadovaneho snimku
00271 */
00272 inline TUnitRetTypeInterface* TSimpleUnitProcessingInterface_integer::GetResult( DWORD id ) 
00273 {
00274         //TODO - mozna by se vyplatilo zahodit vsechny vysledky starsi nez ten posledni pozadovany
00275 
00276         TUnitRetType_integer_implemented * res = NULL;
00277 
00278         m_cs_res.Enter();
00279                 //musime nalezt snimek s pozadovanym ID a vratit vysledek
00280                 const size_t size = m_resultsID.size();
00281                 for ( size_t i = 0 ; i < size ; i++ )
00282                 {
00283                         if ( id == m_resultsID[i] )
00284                         {
00285                                 //nasli jsme pozadovany vysledek
00286                                 res = m_results[i];
00287                                 res->AddRefs();
00288                                 break;
00289                         }
00290                 }
00291         m_cs_res.Leave();
00292 
00293         return res; 
00294 };
00295 //OK 2007-08-26 00:00:56 B04-315B\Tom
00296 
00297 /** Pridani noveho vysledku do seznamu vysledku.
00298 *
00299 *       Vysledek je pridan na konec seznamu.
00300 *
00301 *       \param  id              [in] identifikace snimku pro nejz je vysledek urcen
00302 *       \param  res             [in] platny vysledek - metoda nezvysuje pocet referenci na nej !!!
00303 */
00304 inline void 
00305 TSimpleUnitProcessingInterface_integer::AddResult( DWORD id, TUnitRetType_integer_implemented * res )
00306 {
00307         m_cs_res.Enter();
00308                 m_results.push_back( res );
00309                 m_resultsID.push_back( id );
00310 
00311                 //odstranime zastarale prvky
00312                 if ( m_results.size() > sc_memory )
00313                 {
00314                         TUnitRetType_integer_implemented * ptr = m_results.front();
00315                         ptr->Release();
00316 
00317                         m_results.pop_front();
00318                         m_resultsID.pop_front();
00319                 }
00320         m_cs_res.Leave();
00321 }
00322 //OK 2007-08-26 00:01:05 B04-315B\Tom
00323 
00324 /** Vrati novy objekt z manageru objektu.
00325 *
00326 *       Tento objekt je dale ve vlastnictvi aplikace dokud jej nevrati zpet do manageru
00327 *       pomoci metody ReturnObject();
00328 *
00329 *       Metoda je volana z metody ProcessFrame().
00330 */
00331 inline TUnitRetType_integer_implemented*
00332 TSimpleUnitProcessingInterface_integer::GetObject(void)
00333 {
00334         m_cs_manager.Enter();
00335                 TUnitRetType_integer_implemented * ptr = m_objects.GetItem();
00336         m_cs_manager.Leave();
00337 
00338         //re-inicializace objektu
00339         ptr->Reset();
00340 
00341         ptr->SetParent( this );
00342 
00343         return ptr;
00344 }
00345 //OK 2007-08-26 00:01:28 B04-315B\Tom
00346 
00347 /** Vrati zpet do manageru objekt ziskany metodou GetObject().
00348 *
00349 *       Metoda by mela byt volana z metody Release() vraceneho objektu.
00350 *
00351 *       \param  object  [in] vraceny objekt - metoda jej zaradi do manageru a pri pristim
00352 *                                       pouziti jej manager znovu reinicializuje
00353 */
00354 inline void
00355 TSimpleUnitProcessingInterface_integer::ReturnObject( TUnitRetType_integer_implemented * object )
00356 {
00357         m_cs_manager.Enter();
00358                 //vratime objekt do manageru
00359                 m_objects.PushItem( object );
00360         m_cs_manager.Leave();
00361 }
00362 //OK 2007-08-26 00:01:38 B04-315B\Tom
00363 
00364 // TSimpleUnitProcessingInterface_integer
00365 ////////////////////////////////////////////////////////////////////////////////
00366 ////////////////////////////////////////////////////////////////////////////////
00367 ////////////////////////////////////////////////////////////////////////////////
00368 
00369 }; //END of namespace NSSimpleUnit
00370 using namespace NSSimpleUnit;
00371 
00372 #endif

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