CEventManager Class Reference

#include <Event.h>

Public Member Functions

 CEventManager ()
 ~CEventManager ()
int Initialize (EventType Type, int n)
Event * New (EventType Type)
void Free (Event *event)

Private Attributes

EventDataRequest * m_VectorRTDataRequest
EventQueue m_FreeRTDataRequest
EventDataRequest * m_VectorNRTDataRequest
EventQueue m_FreeNRTDataRequest
EventStorageRequest * m_VectorStorageRequest
EventQueue m_FreeStorageRequest
EventStorageReply * m_VectorStorageReply
EventQueue m_FreeStorageReply
EventAddDisk * m_VectorAddDisk
EventQueue m_FreeAddDisk
EventTimeOut * m_VectorTimeOut
EventQueue m_FreeTimeOut
EventStorageDown * m_VectorStorageDown
EventQueue m_FreeStorageDown
EventStorageUp * m_VectorStorageUp
EventQueue m_FreeStorageUp
EventFinalizeThread * m_VectorFinalizeThread
EventQueue m_FreeFinalizeThread

Detailed Description

Definition at line 119 of file Event.h.

Constructor & Destructor Documentation

CEventManager::CEventManager (  ) 

Definition at line 33 of file Event.cpp.

00034 {
00035     m_VectorRTDataRequest  = 0;
00036     // m_FreeRTDataRequest  does not need to be initialized
00037     m_VectorNRTDataRequest = 0;
00038     // m_FreeNRTDataRequest does not need to be initialized
00039     m_VectorStorageRequest = 0;
00040     // m_FreeStorageRequest does not need to be initialized
00041     m_VectorStorageReply   = 0;
00042     // m_FreeStorageReply   does not need to be initialized
00043     m_VectorAddDisk        = 0;
00044     // m_FreeAddDisk        does not need to be initialized
00045     m_VectorTimeOut        = NULL;
00046     // m_FreeTimeOut        does not need to be initialized
00047     // Novos eventos para tratar da queda/reinicio dos servidores de 
00048     // armazenamento.
00049     m_VectorStorageDown    = NULL;
00050     // m_FreeStorageDown    does not need to be initialized
00051     m_VectorStorageDown      = NULL;
00052     // m_FreeStorageUp      does not need to be initialized
00053     m_VectorFinalizeThread = NULL;
00054     // m_FreeFinalizeRouter does not need to be initialized
00055 }

CEventManager::~CEventManager (  ) 

Definition at line 59 of file Event.cpp.

00060 {
00061     if( m_VectorRTDataRequest  != 0 )   delete[] m_VectorRTDataRequest;
00062     if( m_VectorNRTDataRequest != 0 )   delete[] m_VectorNRTDataRequest;
00063     if( m_VectorStorageRequest != 0 )   delete[] m_VectorStorageRequest;
00064     if( m_VectorStorageReply   != 0 )   delete[] m_VectorStorageReply;
00065     if( m_VectorAddDisk        != 0 )   delete[] m_VectorAddDisk;
00066     // Novos eventos para tratar da queda/reinicio dos servidores de 
00067     // armazenamento.
00068     if( m_VectorStorageDown    != 0 )   delete[] m_VectorStorageDown;
00069     if( m_VectorStorageUp      != 0 )   delete[] m_VectorStorageUp;
00070     // Novo evento para finalizar as threads (que usem uma fila). 
00071     if( m_VectorFinalizeThread != 0 )   delete[] m_VectorFinalizeThread;
00072 }

Member Function Documentation

void CEventManager::Free ( Event *  event  ) 

Definition at line 301 of file Event.cpp.

00302 {
00303     switch( event->Type )
00304     {
00305         case EventTypeRTDataRequest:
00306             m_FreeRTDataRequest.Put( event );
00307             break;
00308         case EventTypeNRTDataRequest:
00309             m_FreeNRTDataRequest.Put( event );
00310             break;
00311         case EventTypeStorageRequest:
00312             m_FreeStorageRequest.Put( event );
00313             break;
00314         case EventTypeStorageReply:
00315             m_FreeStorageReply.Put( event );
00316             break;
00317         case EventTypeAddDisk:
00318             m_FreeAddDisk.Put( event );
00319             break;
00320         case EventTypeTimeOut:
00321             m_FreeAddDisk.Put( event );
00322             break;
00323         // Novos eventos para tratar da queda/reinicio dos servidores de 
00324         // armazenamento.
00325         // Evento gerado quando detectamos que um servidor de armazenamento 
00326         // parou de funcionar.    
00327         case EventTypeStorageDown:
00328             m_FreeStorageDown.Put( event );
00329             break;
00330         // Evento gerado quando conseguimos restabelecer, com sucesso, uma 
00331         // conexao com um servidor de armazenamento que tinha parado de 
00332         // funcionar.  
00333         case EventTypeStorageUp:
00334             m_FreeStorageUp.Put( event );
00335             break;
00336         // Novo evento para finalizar uma thread que use uma fila. 
00337         case EventTypeFinalizeThread:
00338             m_FreeFinalizeThread.Put( event );
00339             break;
00340 
00341         default:
00342             RioErr << "CEventManager::Free(): Invalid Event Type: "
00343                   << ( unsigned int ) event->Type << endl;
00344             break;
00345     }
00346 }

int CEventManager::Initialize ( EventType  Type,
int  n 
)

Definition at line 79 of file Event.cpp.

00080 {
00081     int i;
00082 
00083     switch( Type )
00084     {
00085         case EventTypeRTDataRequest:
00086             if( m_VectorRTDataRequest != 0 ) delete[] m_VectorRTDataRequest;
00087             m_VectorRTDataRequest = new EventDataRequest[n];
00088             if( m_VectorRTDataRequest == 0 )
00089             {
00090                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00091                        << " for EventDataRequest free list (Out of memory)"
00092                        << endl;
00093                 return (ERROR_EVENT + ERROR_MEMORY);
00094             }
00095             for( i = 0; i < n; i++ )
00096             {
00097                 m_VectorRTDataRequest[i].Header.Type = EventTypeRTDataRequest;
00098                 m_FreeRTDataRequest.Put( (Event*) &m_VectorRTDataRequest[i] );
00099             }
00100             break;
00101 
00102         case EventTypeNRTDataRequest:
00103             if( m_VectorNRTDataRequest != 0 ) delete[] m_VectorNRTDataRequest;
00104             m_VectorNRTDataRequest = new EventDataRequest[n];
00105             if( m_VectorNRTDataRequest == 0 )
00106             {
00107                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00108                        << " for EventDataRequest free list (Out of memory)"
00109                        << endl;
00110                 return (ERROR_EVENT + ERROR_MEMORY);
00111             }
00112             for( i = 0; i < n; i++ )
00113             {
00114                 m_VectorNRTDataRequest[i].Header.Type = EventTypeNRTDataRequest;
00115                 m_FreeNRTDataRequest.Put( (Event*) &m_VectorNRTDataRequest[i] );
00116             }
00117             break;
00118 
00119         case EventTypeStorageRequest:
00120             if( m_VectorStorageRequest != 0 ) delete[] m_VectorStorageRequest;
00121             m_VectorStorageRequest = new EventStorageRequest[n];
00122             if( m_VectorStorageRequest == 0 )
00123             {
00124                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00125                        << " for EventStorageRequest free list (Out of memory)"
00126                        << endl;
00127                 return ( ERROR_EVENT + ERROR_MEMORY );
00128             }
00129             for( i = 0; i < n; i++ )
00130             {
00131                 m_VectorStorageRequest[i].Header.Type = EventTypeStorageRequest;
00132                 m_VectorStorageRequest[i].StorageRequest.Header.Type  = MSG_RSS_NODEINFO_REQ;
00133                 m_VectorStorageRequest[i].StorageRequest.Header.Size  = SizeMsgRSSnodeInfoReq;
00134 
00135                 m_FreeStorageRequest.Put( (Event*) &m_VectorStorageRequest[i] );
00136             }
00137             break;
00138 
00139         case EventTypeStorageReply:
00140             if( m_VectorStorageReply != 0 ) delete[] m_VectorStorageReply;
00141             m_VectorStorageReply = new EventStorageReply[n];
00142             if( m_VectorStorageReply == 0 )
00143             {
00144                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00145                        << " for EventStorageReply free list (Out of memory)"
00146                        << endl;
00147                 return ( ERROR_EVENT + ERROR_MEMORY );
00148             }
00149             for( i = 0; i < n; i++ )
00150             {
00151                 m_VectorStorageReply[i].Header.Type = EventTypeStorageReply;
00152                 m_FreeStorageReply.Put( (Event*) &m_VectorStorageReply[i] );
00153             }
00154             break;
00155 
00156         case EventTypeAddDisk:
00157             if( m_VectorAddDisk != 0 ) delete[] m_VectorAddDisk;
00158             m_VectorAddDisk = new EventAddDisk[n];
00159             if( m_VectorAddDisk == 0 )
00160             {
00161                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00162                        << " for EventAddDisk free list (Out of memory)" << endl;
00163                 return ( ERROR_EVENT + ERROR_MEMORY );
00164             }
00165             for( i = 0; i < n; i++ )
00166             {
00167                 m_VectorAddDisk[i].Header.Type = EventTypeAddDisk;
00168                 m_FreeAddDisk.Put( (Event*) &m_VectorAddDisk[i] );
00169             }
00170             break;
00171 
00172         case EventTypeTimeOut:
00173             if( m_VectorTimeOut != 0 )
00174                 delete[] m_VectorTimeOut;
00175             m_VectorTimeOut = new EventTimeOut[n];
00176             if( m_VectorTimeOut == 0 )
00177             {
00178                 RioErr << "CEventManager::Initialize(): Failed to allocate space "
00179                        << " for EventTimeOut free list (Out of memory)" << endl;
00180                 return ( ERROR_EVENT + ERROR_MEMORY );
00181             }
00182             for( i = 0; i < n; i++ )
00183             {
00184                 m_VectorTimeOut[i].Header.Type = EventTypeTimeOut;
00185                 m_FreeTimeOut.Put( (Event*) &m_VectorTimeOut[i] );
00186             }
00187             break;
00188         // Novos eventos para tratar da queda/reinicio dos servidores de 
00189         // armazenamento.
00190         // Evento gerado quando detectamos que um servidor de armazenamento 
00191         // parou de funcionar.    
00192         case EventTypeStorageDown:
00193             if( m_VectorStorageDown != 0 )
00194                 delete[] m_VectorStorageDown;
00195             m_VectorStorageDown = new EventStorageDown[ n ];
00196             if( m_VectorStorageDown == 0 )
00197             {
00198                 RioErr << "CEventManager::Initialize(): Failed to allocate "
00199                        << "space for EventStorageDown free list (Out of memory)" 
00200                        << endl;
00201                 return ( ERROR_EVENT + ERROR_MEMORY );
00202             }
00203             for( i = 0; i < n; i++ )
00204             {
00205                 m_VectorStorageDown[ i ].Header.Type = EventTypeStorageDown;
00206                 m_FreeStorageDown.Put( (Event*) &m_VectorStorageDown[ i ] );
00207             }
00208             break;
00209         // Evento gerado quando conseguimos restabelecer, com sucesso, uma 
00210         // conexao com um servidor de armazenamento que tinha parado de 
00211         // funcionar.  
00212         case EventTypeStorageUp:
00213             if( m_VectorStorageUp != 0 )
00214                 delete[] m_VectorStorageUp;
00215             m_VectorStorageUp = new EventStorageUp[ n ];
00216             if( m_VectorStorageUp == 0 )
00217             {
00218                 RioErr << "CEventManager::Initialize(): Failed to allocate "
00219                        << "space for EventStorageUp free list (Out of memory)" 
00220                        << endl;
00221                 return ( ERROR_EVENT + ERROR_MEMORY );
00222             }
00223             for( i = 0; i < n; i++ )
00224             {
00225                 m_VectorStorageUp[ i ].Header.Type = EventTypeStorageUp;
00226                 m_FreeStorageUp.Put( (Event*) &m_VectorStorageUp[ i ] );
00227             }
00228             break;
00229         // Novo evento para finalizar uma thread que use uma fila.
00230         case EventTypeFinalizeThread:
00231             if( m_VectorFinalizeThread != 0 )
00232                 delete[] m_VectorFinalizeThread;
00233             m_VectorFinalizeThread = new EventFinalizeThread[ n ];
00234             if( m_VectorFinalizeThread == 0 )
00235             {
00236                 RioErr << "CEventManager::Initialize(): Failed to allocate "
00237                        << "space for EventFinalizeThread free list (Out of "
00238                        << "memory)" << endl;
00239                 return ( ERROR_EVENT + ERROR_MEMORY );
00240             }     
00241             for( i = 0; i < n; i++ )
00242             {
00243                 m_VectorFinalizeThread[ i ].Header.Type = 
00244                                                         EventTypeFinalizeThread;
00245                 m_FreeFinalizeThread.Put( ( Event* )  
00246                                                  &m_VectorFinalizeThread[ i ] );
00247             }
00248             break;
00249 
00250         default:
00251             RioErr << "CEventManager::Initialize(): Invalid Event Type: "
00252                    << (unsigned int) Type << endl;
00253             return ( ERROR_EVENT + ERROR_INVALID_PARAM );
00254     }
00255 
00256     return 0;
00257 }

Event * CEventManager::New ( EventType  Type  ) 

Definition at line 261 of file Event.cpp.

00262 {
00263     switch( Type )
00264     {
00265         case EventTypeRTDataRequest:
00266             return ( m_FreeRTDataRequest.Get() );
00267         case EventTypeNRTDataRequest:
00268             return ( m_FreeNRTDataRequest.Get() );
00269         case EventTypeStorageRequest:
00270             return ( m_FreeStorageRequest.Get() );
00271         case EventTypeStorageReply:
00272             return ( m_FreeStorageReply.Get() );
00273         case EventTypeAddDisk:
00274             return ( m_FreeAddDisk.Get() );
00275         case EventTypeTimeOut:
00276             return ( m_FreeTimeOut.Get() );
00277         // Novos eventos para tratar da queda/reinicio dos servidores de 
00278         // armazenamento.
00279         // Evento gerado quando detectamos que um servidor de armazenamento 
00280         // parou de funcionar.    
00281         case EventTypeStorageDown:
00282             return ( m_FreeStorageDown.Get() );
00283         // Evento gerado quando conseguimos restabelecer, com sucesso, uma 
00284         // conexao com um servidor de armazenamento que tinha parado de 
00285         // funcionar.  
00286         case EventTypeStorageUp:
00287             return ( m_FreeStorageUp.Get() );
00288         // Novo evento para finalizar uma thread que use uma fila. 
00289         case EventTypeFinalizeThread:
00290             return ( m_FreeFinalizeThread.Get() );
00291             
00292         default:
00293             RioErr << "CEventManager::New(): Invalid Event Type: "
00294                   << (unsigned int) Type << endl;
00295             return 0;
00296     }
00297 }

Field Documentation

EventQueue CEventManager::m_FreeAddDisk [private]

Definition at line 139 of file Event.h.

EventQueue CEventManager::m_FreeFinalizeThread [private]

Definition at line 147 of file Event.h.

EventQueue CEventManager::m_FreeNRTDataRequest [private]

Definition at line 133 of file Event.h.

EventQueue CEventManager::m_FreeRTDataRequest [private]

Definition at line 131 of file Event.h.

EventQueue CEventManager::m_FreeStorageDown [private]

Definition at line 143 of file Event.h.

EventQueue CEventManager::m_FreeStorageReply [private]

Definition at line 137 of file Event.h.

EventQueue CEventManager::m_FreeStorageRequest [private]

Definition at line 135 of file Event.h.

EventQueue CEventManager::m_FreeStorageUp [private]

Definition at line 145 of file Event.h.

EventQueue CEventManager::m_FreeTimeOut [private]

Definition at line 141 of file Event.h.

EventAddDisk* CEventManager::m_VectorAddDisk [private]

Definition at line 138 of file Event.h.

EventFinalizeThread* CEventManager::m_VectorFinalizeThread [private]

Definition at line 146 of file Event.h.

EventDataRequest* CEventManager::m_VectorNRTDataRequest [private]

Definition at line 132 of file Event.h.

EventDataRequest* CEventManager::m_VectorRTDataRequest [private]

Definition at line 130 of file Event.h.

EventStorageDown* CEventManager::m_VectorStorageDown [private]

Definition at line 142 of file Event.h.

EventStorageReply* CEventManager::m_VectorStorageReply [private]

Definition at line 136 of file Event.h.

EventStorageRequest* CEventManager::m_VectorStorageRequest [private]

Definition at line 134 of file Event.h.

EventStorageUp* CEventManager::m_VectorStorageUp [private]

Definition at line 144 of file Event.h.

EventTimeOut* CEventManager::m_VectorTimeOut [private]

Definition at line 140 of file Event.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:31 2012 for RIO by  doxygen 1.6.3