CTransferInfo Class Reference

#include <NetInterface.h>

Public Member Functions

 CTransferInfo (CNetInterface *NetInterface)
 Construtor da classe, usado para criar um novo objeto desta classe.
 ~CTransferInfo ()
 Destrutor da classe, usado para remover um objeto desta classe criado anteriormente.
RioResult NewTransfer (int IP, int Port, callback_t FinalizeCallback, void *FinalizeCallbackParam, cmdcallback_t ProcessCallback, void *ProcessCallbackParam, char *Data, unsigned int DataSize, ETransferType TransferType, TTransferID DestTransferID, TTransferID *TransferID=NULL)
 Funcao para criar uma nova estrutura para gerenciar uma transferencia.
RioResult RemoveTransfer (TTransferID TransferID)
 Funcao para remover uma estrutura de transferencia.
RioResult GetTransfer (TTransferID TransferID, int *IP, int *Port, callback_t *FinalizeCallback, void **FinalizeCallbackParam, cmdcallback_t *ProcessCallback, void **ProcessCallbackParam, char **Data, unsigned int *DataSize, ETransferType *TransferType, TTransferID *DestTransferID=NULL)
 Funcao para buscar por uma estrutura de transferencia cuja ID e passada como parametro, e retornar as informacoes sobre esta transferencia.
RioResult FinalizeAllTransfers (int IP, int Port, ETransferType TransferType, RioResult RioError)
 Funcao para chamar todas as callbacks de finalizacao da transferencia para as transferencias associadas ao par IP, porta passado como parametro, e depois remover todas as estruturas de transferencia associadas ao mesmo par IP, porta.

Static Public Attributes

static const TTransferID NullTransferID = -1

Private Member Functions

TTransferInfoHash::iterator FindTransferID (TTransferID TransferID)
 Funcao para achar o ID TransferID na hash.

Private Attributes

CNetInterface * m_NetInterface
TTransferID m_NextTransferID
TTransferInfoHash m_TransferInfoHash
pthread_mutex_t m_Mutex

Detailed Description

Definition at line 163 of file NetInterface.h.

Constructor & Destructor Documentation

CTransferInfo::CTransferInfo ( CNetInterface *  NetInterface  ) 

Construtor da classe, usado para criar um novo objeto desta classe.

Parameters:
ponteiro para o objeto da classe CNetInterface que gerencia as transferencias.

Definition at line 55 of file NetInterface.cpp.

00056 {
00057     // Inicializa o ponteiro para a classe gerenciadora as conexoes (necessario
00058     // para fazermos a impressao a seguir.
00059     m_NetInterface = NetInterface;    
00060 
00061     #ifdef RIO_DEBUG1
00062     TRANSFERINFOLOG << "[CTransferInfo - Construtor] Start" << endl;
00063     #endif
00064     
00065     // Inicializa as variaveis da classe (nao vou usar o 0 porque este valor 
00066     // era reservado na RioNeti e nao tenho certeza se ele pode ser usado, e eu
00067     // tambem preciso de um valor invalido para ser retornado pela funcao 
00068     // NewTransfer, caso ela falhe em criar uma nova estrutura na hash).
00069     m_NextTransferID = 1;
00070 
00071     // m_TransferInfoHash nao precisa ser inicializado.
00072 
00073     // Inicializa o mutex.
00074     pthread_mutex_init( &m_Mutex, NULL );
00075 
00076     #ifdef RIO_DEBUG1
00077     TRANSFERINFOLOG << "[CTransferInfo - Construtor] Finish" << endl;
00078     #endif
00079 }

CTransferInfo::~CTransferInfo (  ) 

Destrutor da classe, usado para remover um objeto desta classe criado anteriormente.

Definition at line 83 of file NetInterface.cpp.

00084 {
00085     // Armazena o codigo de retorno da funcao FinalizeAllTransfers.
00086     RioResult RioStatus;
00087     
00088     #ifdef RIO_DEBUG1
00089     TRANSFERINFOLOG << "[CTransferInfo - Destrutor] Start" << endl;
00090     #endif
00091     
00092     // Finaliza todas as transferencias
00093     RioStatus = FinalizeAllTransfers( 0, 0, UNDEFINEDTYPE, 
00094                                       ERROR_TRANSFERINFO + 
00095                                       ERROR_PROCESS_TERMINATED );
00096     #ifdef RIO_DEBUG2
00097     if( FAILED( RioStatus ) )
00098     {
00099         TRANSFERINFOLOG << "[CTransferInfo::~CTransferInfo] Erro 0x" << hex 
00100                         << RioStatus << dec << " (" 
00101                         << GetErrorDescription( RioStatus ) << ") ao executar "
00102                         << "a funcao FinalizeAllTransfers." << endl;
00103     }
00104     #endif
00105 
00106     // Destroi o mutex.
00107     pthread_mutex_destroy( &m_Mutex );
00108 
00109     #ifdef RIO_DEBUG1
00110     TRANSFERINFOLOG << "[CTransferInfo - Destrutor] Finish" << endl;
00111     #endif
00112 }

Member Function Documentation

RioResult CTransferInfo::FinalizeAllTransfers ( int  IP,
int  Port,
ETransferType  TransferType,
RioResult  RioError 
)

Funcao para chamar todas as callbacks de finalizacao da transferencia para as transferencias associadas ao par IP, porta passado como parametro, e depois remover todas as estruturas de transferencia associadas ao mesmo par IP, porta.

As callbacks serao finalizadas com o erro passado como parametro.

Obs: Se o ponteiro para os dados passados ao criarmos a estrutura para a transferencia nao for NULL, entao os dados tambem serao removidos. Obs2: se IP e Port foram ambos 0, todas as transferencias serao finalizadas (esta chamada e usada pelo destrutor da classe para garantir que todas as transferencias foram finalizadas).

Parameters:
IP endereco IP para o qual desejamos finalizar todas as transferencias que estao pendentes.
Port porta para a qual desejamos finalizar todas as transferencias pendentes.
TransferType tipo de transferencia que desejamos fechar. Se for igual a UNDEFINEDTYPE, todas as transferencias (de leitura e de escrita) serao fechadas. Caso contrario, somente as transferencias do tipo dado serao fechadas.
RioError erro a ser passado quando as callbaks forem chamadas.
Returns:
S_OK se as estruturas de transferencia associadas ao par IP, porta foram removidas com sucesso ou o codigo de erro em caso contrario (note que as callbacks nao gerarao erros porque sao funcoes cujo retorno e do tipo void).

Definition at line 428 of file NetInterface.cpp.

00431 {
00432     // Armazena um iterador para a hash.
00433     TTransferInfoHash::iterator HashTransfer, NextHashTransfer;
00434 
00435     #ifdef RIO_DEBUG2
00436     // Variaveis usadas para imprimir os IPs.
00437     in_addr ip, iph;
00438     // Iterador usado para imprimir a hash.
00439     TTransferInfoHash::iterator AuxIterator;
00440     
00441     ip.s_addr = IP;
00442     #endif
00443 
00444     #ifdef RIO_DEBUG1
00445     TRANSFERINFOLOG << "[CTransferInfo - FinalizeAllTransfers] Start" << endl;
00446     #endif
00447 
00448     // Obtem o acesso exclusivo as variaveis do objeto.
00449     pthread_mutex_lock( &m_Mutex );
00450 
00451     #ifdef RIO_DEBUG2
00452     TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers hash das "
00453                     << "transferencias, com " << m_TransferInfoHash.size() 
00454                     << " entradas: ";
00455     
00456     AuxIterator = m_TransferInfoHash.begin();
00457     if( AuxIterator != m_TransferInfoHash.end() )
00458     {
00459         while( AuxIterator != m_TransferInfoHash.end() )
00460         {
00461             iph.s_addr = ( * AuxIterator ).second.IP;
00462             TRANSFERINFOLOG << "[" << ( * AuxIterator ).first << ", <IP="
00463                             << inet_ntoa( iph ) << ", Port="
00464                             << ntohs( ( * AuxIterator ).second.Port )  
00465                             << ", FinalizeCallback=0x" << hex 
00466                             << ( unsigned long ) 
00467                                        ( * AuxIterator ).second.FinalizeCallback
00468                             << ", FinalizeCallbackParam=0x" 
00469                             << ( unsigned long ) 
00470                                   ( * AuxIterator ).second.FinalizeCallbackParam
00471                             << ", ProcessCallback=0x" 
00472                             << ( unsigned long ) 
00473                                         ( * AuxIterator ).second.ProcessCallback
00474                             << ", ProcessCallbackParam=0x" 
00475                             << ( unsigned long ) 
00476                                    ( * AuxIterator ).second.ProcessCallbackParam
00477                             << ", Data=0x" << ( unsigned long )
00478                                                    ( * AuxIterator ).second.Data
00479                             << dec << ", DataSize=" 
00480                             << ( * AuxIterator ).second.DataSize 
00481                             << ", TransferType="  
00482                             << ( * AuxIterator ).second.TransferType 
00483                             << ">]";
00484             AuxIterator++;
00485             if( AuxIterator != m_TransferInfoHash.end() )
00486                 TRANSFERINFOLOG << ", ";
00487             else
00488                 TRANSFERINFOLOG << "." << endl;
00489         }
00490     }
00491     else
00492     {
00493         TRANSFERINFOLOG << "<<< HASH VAZIA!>>>." << endl;
00494     }
00495     #endif           
00496 
00497     // Varre todas as entradas da hash para procurar pelo par IP, Port. 
00498     // Obs: Eu nao sei ainda como podemos fazer isso de modo mais eficiente, 
00499     // mas esta funcao somente sera usada quando o socket associado ao par IP,
00500     // porta for fechado (pelo outro lado ou por timeout).
00501     
00502     HashTransfer = m_TransferInfoHash.begin();
00503     while( HashTransfer != m_TransferInfoHash.end() )
00504     {
00505         #ifdef RIO_DEBUG2
00506         TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers antes de "
00507                         << "incrementar o iterador HashTransfer e atribui-lo a "
00508                         << "NextHashTransfer." << endl;
00509         #endif
00510         // Armazena o ponteiro para a proximo elemento da hash.
00511         NextHashTransfer = HashTransfer;
00512         NextHashTransfer++;
00513 
00514         #ifdef RIO_DEBUG2
00515         TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers depos de "
00516                         << "incrementar o iterador HashTransfer e atribui-lo a "
00517                         << "NextHashTransfer, e antes de executar o IP." 
00518                         << endl;
00519         #endif
00520         // Verifica se a entrada atual da hash esta associada ao par IP, porta,
00521         // e se o tipo e o correto (o tipo UNDEFINEDTYPE define que as 
00522         // transferencias).
00523         if( ( ( ( IP == 0 ) && ( Port == 0 ) ) || 
00524              ( ( ( *HashTransfer ).second.IP == IP ) && 
00525                ( ( *HashTransfer ).second.Port == Port ) ) ) && 
00526              ( ( TransferType == UNDEFINEDTYPE ) ||
00527                ( TransferType == ( *HashTransfer ).second.TransferType ) ) ) 
00528         {
00529             #ifdef RIO_DEBUG2
00530             TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers Iniciando "
00531                             << "a remocao da transferencia com a ID " 
00532                             << ( *HashTransfer ).second.TransferID 
00533                             << " associada ao IP " << inet_ntoa( ip ) 
00534                             << " e a porta " << ntohs( Port ) << "." << endl;
00535             #endif
00536 
00537             // Chama a callback com o erro RioError, se ela nao for NULL
00538             if( ( *HashTransfer ).second.FinalizeCallback != NULL )
00539             {
00540                 #ifdef RIO_DEBUG2
00541                 TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers "
00542                                 << "chamando a callback associada a "
00543                                 << "transferencia com a ID " 
00544                                 << ( *HashTransfer ).second.TransferID 
00545                                 << " com o erro 0x" << hex << RioError << dec
00546                                 << " (" << GetErrorDescription( RioError )
00547                                 << ")." << endl;
00548                 #endif
00549                 
00550                 ( *HashTransfer ).second.FinalizeCallback( 
00551                                  ( *HashTransfer ).second.FinalizeCallbackParam, 
00552                                                            RioError );
00553             }
00554 
00555             #ifdef RIO_DEBUG2
00556             TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers removendo "
00557                             << "a transferencia com a ID " 
00558                             << ( *HashTransfer ).second.TransferID << "." 
00559                             << endl;
00560             #endif
00561                 
00562             // Deleta a chave atual associada ao par IP, Porta da hash.
00563             m_TransferInfoHash.erase( HashTransfer );
00564             
00565             // Deleta os dados, se for uma transferencia associada ao envio de
00566             // dados.
00567             if( ( *HashTransfer ).second.TransferType == SENDINGDATA )
00568                 delete[] ( *HashTransfer ).second.Data;
00569                             
00570             #ifdef RIO_DEBUG2
00571             TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers depois de "
00572                             << "ter removido a transferencia." << endl;
00573             #endif
00574         }
00575         
00576         #ifdef RIO_DEBUG2
00577         TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers antes de " 
00578                         << "atualizar HashTransfer." << endl;
00579         #endif
00580 
00581         // Atualiza HashTransfer para o proximo elemento da hash.
00582         HashTransfer = NextHashTransfer;
00583 
00584         #ifdef RIO_DEBUG2
00585         TRANSFERINFOLOG << "CTransferInfo::FinalizeAllTransfers depois de " 
00586                         << "atualizar HashTransfer." << endl;
00587         #endif
00588     }
00589 
00590     // Libera o acesso exclusivo as variaveis do objeto.
00591     pthread_mutex_unlock( &m_Mutex );
00592 
00593     #ifdef RIO_DEBUG1
00594     TRANSFERINFOLOG << "[CTransferInfo - FinalizeAllTransfers] Finish" << endl;
00595     #endif
00596 
00597     return S_OK;
00598 }

TTransferInfoHash::iterator CTransferInfo::FindTransferID ( TTransferID  TransferID  )  [private]

Funcao para achar o ID TransferID na hash.

Parameters:
TransferID ID a ser buscada.
Returns:
iterador para na hash para o ID se o ID for valido e existir na hash, ou m_TransferInfoHash.end() em caso contrario.

Definition at line 115 of file NetInterface.cpp.

00117 {
00118     #ifdef RIO_DEBUG1
00119     TRANSFERINFOLOG << "[CTransferInfo - FindTransferID] Start" << endl;
00120     #endif
00121 
00122     // Armazena um iterador para a hash.
00123     TTransferInfoHash::iterator HashTransfer;
00124 
00125     // Verifica se a chave passada em TransferID nao e valida.
00126     if( TransferID == NULLTRANSFERID )
00127     {
00128         #ifdef RIO_DEBUG2
00129         TRANSFERINFOLOG << "CTransferInfo::FindTransferID O valor da ID "
00130                         << TransferID << " nao e valido!" << endl;
00131         #endif
00132 
00133         #ifdef RIO_DEBUG1
00134         TRANSFERINFOLOG << "[CTransferInfo - FindTransferID] Finish1" << endl;
00135         #endif
00136         
00137         return m_TransferInfoHash.end();
00138         
00139     }
00140     
00141     // Tenta achar a chave identificada pela ID na hash
00142     HashTransfer = m_TransferInfoHash.find( TransferID );
00143     if( HashTransfer == m_TransferInfoHash.end() )
00144     {
00145         #ifdef RIO_DEBUG2
00146         TRANSFERINFOLOG << "CTransferInfo::FindTransferID O valor da ID "
00147                         << TransferID << " nao e valido, pois nao foi achado" 
00148                         "na hash!" << endl;
00149         #endif
00150 
00151         #ifdef RIO_DEBUG1
00152         TRANSFERINFOLOG << "[CTransferInfo - FindTransferID] Finish2" << endl;
00153         #endif
00154         
00155         return m_TransferInfoHash.end();
00156     }
00157 
00158     #ifdef RIO_DEBUG2
00159     TRANSFERINFOLOG << "CTransferInfo::FindTransferID O valor da ID "
00160                     << TransferID << " e valido!" << endl;
00161     #endif
00162 
00163     #ifdef RIO_DEBUG1
00164     TRANSFERINFOLOG << "[CTransferInfo - FindTransferID] Finish3" << endl;
00165     #endif
00166 
00167     return HashTransfer;
00168 }

RioResult CTransferInfo::GetTransfer ( TTransferID  TransferID,
int *  IP,
int *  Port,
callback_t *  FinalizeCallback,
void **  FinalizeCallbackParam,
cmdcallback_t *  ProcessCallback,
void **  ProcessCallbackParam,
char **  Data,
unsigned int *  DataSize,
ETransferType *  TransferType,
TTransferID *  DestTransferID = NULL 
)

Funcao para buscar por uma estrutura de transferencia cuja ID e passada como parametro, e retornar as informacoes sobre esta transferencia.

Parameters:
TransferID identificador para a transferencia que desejamos obter os dados passados a funcao NewTransfer quando a estrutura para a transferencia foi criada.
IP ponteiro para o endereco para armazenar o endereco IP associado a nova transferencia.
Port ponteiro para o endereco para armazenar a porta associada a nova transferencia.
FinalizeCallback ponteiro para o endereco da callback chamada quando finalizamos a transferencia.
FinalizeCallbackParam ponteiro para o valor a ser passado quando chamarmos a callback FinalizeCallback.
ProcessCallback ponteiro para o endereco da callback chamada para processar um dado.
ProcessCallbackParam ponteiro para o valor a ser passado quando chamarmos a callback FinalizeCallback.
Data ponteiro para armazenar o ponteiro para os dados associados a estrutura de transferencia a ser criada.
DataSize ponteiro para armazenar o numero de bytes nos dados associados a transferencia.
TransferType ponteiro para armazenar o tipo da transferencia: se estamos enviando dados (SENDINGDATA) ou se estamos recebendo dados (RECEIVINGDATA).
DestTransferID ponteiro para armazenar a identificacao da transferencia associada a um envio de dados. Se for NULL (o default, se nao for passado), a ID nao sera retornada (fizemos isso porque, atualmente, somente a funcao ProcessError da classe CNetInterface esta usando este ID, quando ocorre um erro no envio dos dados, para avisar o erro ao outro lado da conexao).
Returns:
S_OK se a estrutura para a transferencia foi criada com sucesso ou o codigo de erro se algum erro ocorrer.

Definition at line 338 of file NetInterface.cpp.

00346 {
00347     // Armazena um iterador para a hash.
00348     TTransferInfoHash::iterator HashTransfer;
00349     
00350     #ifdef RIO_DEBUG1
00351     TRANSFERINFOLOG << "[CTransferInfo - GetTransfer] Start" << endl;
00352     #endif
00353 
00354     // Obtem o acesso exclusivo as variaveis do objeto.
00355     pthread_mutex_lock( &m_Mutex );
00356 
00357     // Procura pelo identificador na hash.
00358     HashTransfer = FindTransferID( TransferID );
00359     if( HashTransfer == m_TransferInfoHash.end() )
00360     {
00361         // Libera o acesso exclusivo as variaveis do objeto.
00362         pthread_mutex_unlock( &m_Mutex );
00363         
00364         // Inicializa os campos passados como parametro com valores de 
00365         // nao-inicializado.
00366         *IP = 0;
00367         *Port = 0;
00368         *FinalizeCallback = NULL;
00369         *FinalizeCallbackParam = NULL;
00370         *ProcessCallback = NULL;
00371         *ProcessCallbackParam = NULL;
00372         *Data = NULL;
00373         *DataSize = 0;
00374         *TransferType = UNDEFINEDTYPE;
00375         // Somente atribuimos este campo se o ponteiro DestTransferID nao for
00376         // NULL (ele somente e usado pela transferencia com o tipo SENDINGDATA,
00377         // de envio de dados, quando ocorre um erro).
00378         if( DestTransferID != NULL )
00379             *DestTransferID = NULLTRANSFERID;
00380         
00381         #ifdef RIO_DEBUG2
00382         TRANSFERINFOLOG << "CTransferInfo::GetTransfer O valor da ID "
00383                         << TransferID << " nao e valido!" << endl;
00384         #endif
00385 
00386         #ifdef RIO_DEBUG1
00387         TRANSFERINFOLOG << "[CTransferInfo - GetTransfer] Finish1" << endl;
00388         #endif
00389         
00390         return ERROR_TRANSFERINFO + ERROR_INVALID_PARAM;
00391     }
00392     
00393     // Inicializa os valores de acordo com as entradas de TransferID na hash.
00394     *IP = ( *HashTransfer ).second.IP;
00395     *Port = ( *HashTransfer ).second.Port;
00396     *FinalizeCallback = ( *HashTransfer ).second.FinalizeCallback;
00397     *FinalizeCallbackParam = ( *HashTransfer ).second.FinalizeCallbackParam;
00398     *ProcessCallback = ( *HashTransfer ).second.ProcessCallback;
00399     *ProcessCallbackParam = ( *HashTransfer ).second.ProcessCallbackParam;
00400     *Data = ( *HashTransfer ).second.Data;
00401     *DataSize = ( *HashTransfer ).second.DataSize;
00402     *TransferType = ( *HashTransfer ).second.TransferType;
00403     // Somente atribuimos este campo se o ponteiro DestTransferID nao for NULL 
00404     // (ele somente e usado pela transferencia com o tipo SENDINGDATA, de envio
00405     // de dados.
00406     if( DestTransferID != NULL )
00407         *DestTransferID = ( *HashTransfer ).second.DestTransferID;
00408         
00409     #ifdef RIO_DEBUG2
00410     TRANSFERINFOLOG << "CTransferInfo::GetTransfer A transferencia com a ID "
00411                     << TransferID << " foi obtida com sucesso!" << endl;
00412     #endif
00413 
00414     // Libera o acesso exclusivo as variaveis do objeto.
00415     pthread_mutex_unlock( &m_Mutex );
00416 
00417     #ifdef RIO_DEBUG1
00418     TRANSFERINFOLOG << "[CTransferInfo - GetTransfer] Finish2" << endl;
00419     #endif
00420     
00421     return S_OK;
00422 }

RioResult CTransferInfo::NewTransfer ( int  IP,
int  Port,
callback_t  FinalizeCallback,
void *  FinalizeCallbackParam,
cmdcallback_t  ProcessCallback,
void *  ProcessCallbackParam,
char *  Data,
unsigned int  DataSize,
ETransferType  TransferType,
TTransferID  DestTransferID,
TTransferID *  TransferID = NULL 
)

Funcao para criar uma nova estrutura para gerenciar uma transferencia.

Parameters:
IP endereco IP associado a nova transferencia.
Port Porta associada a nova transferencia.
FinalizeCallback callback chamada quando finalizamos a transferencia.
FinalizeCallbackParam valor a ser passado quando chamarmos a callback FinalizeCallback.
ProcessCallback callback chamada para processar um dado recebido. Neste caso, a transrencia nao sera finalizada, e um novo dado devera ser recebido para finaliza-la (esta callback somente e chamada para os dados do tipo CMDDATA).
ProcessCallbackParam valor a ser passado quando chamarmos a callback ProcessCallback.
Data dados associados a estrutura de transferencia a ser criada.
DataSize numero de bytes nos dados associados a transferencia.
TransferType tipo da transferencia: se estamos enviando dados (SENDINGDATA) ou se estamos recebendo dados (RECEIVINGDATA).
DestTransferID Identificador da transferencia de destino. Ele e usado somente quando enviamos dados, e diz qual e a identificacao da transferencia, no outro lado, que recebera os dados. Atualmente, e somente usado quando finalizamos as conexoes ou quando ocorre um erro ao escrevermos os dados.
TransferID ponteiro para um valor que recebera a ID associada a transferencia (usado para buscar pela estrutura associada a esta transferencia). Se for NULL, o identificador nao sera armazenado.
Returns:
S_OK se a estrutura para a transferencia foi criada com sucesso ou o codigo de erro se algum erro ocorrer.

Definition at line 171 of file NetInterface.cpp.

00180 {
00181     // Estutura para armazenar os dados associados a nova transferencia.
00182     STransferInfo TransferInfo;
00183     // Armazena um iterador para a hash.
00184     TTransferInfoHash::iterator HashTransfer;
00185     // Valor booleano usado para indicar se devemos ou nao continuar pela busca
00186     // de um ID que nao esta na hash.
00187     bool searchTransferID;
00188 
00189     #ifdef RIO_DEBUG1
00190     TRANSFERINFOLOG << "[CTransferInfo - NewTransfer] Start" << endl;
00191     #endif
00192     
00193     // Obtem o acesso exclusivo as variaveis do objeto.
00194     pthread_mutex_lock( &m_Mutex );
00195     
00196     // Fica em um laco tentando descobrir qual ID nao esta sendo usada (apesar
00197     // de termos um laco, ele nao deveria ser demorado, porque o tipo 
00198     // TTransferID, usado como uma chave da hash, e um inteiro de 64 bits.
00199     searchTransferID = true;
00200     do
00201     {
00202         HashTransfer = m_TransferInfoHash.find( m_NextTransferID );
00203         if( ( HashTransfer != m_TransferInfoHash.end() ) &&
00204             ( m_NextTransferID != NULLTRANSFERID ) && 
00205             ( m_NextTransferID != 0 ) ) // Como o valor 0 estave reservado na
00206                                         // RioNeti, eu deixei ele reservado aqui
00207                                         // para evitar problemas futuros. 
00208             m_NextTransferID++;
00209         else
00210             searchTransferID = false;
00211     } while( searchTransferID );
00212     
00213     // Inicializa os campos da estrutura TransferInfo a ser colocada na hash
00214     // usando a chave cujo valor e dado em m_NextTransferID.
00215     TransferInfo.IP = IP;
00216     TransferInfo.Port = Port;
00217     TransferInfo.FinalizeCallback = FinalizeCallback;
00218     TransferInfo.FinalizeCallbackParam = FinalizeCallbackParam;
00219     TransferInfo.ProcessCallback = ProcessCallback;
00220     TransferInfo.ProcessCallbackParam = ProcessCallbackParam;
00221     TransferInfo.Data = Data;
00222     TransferInfo.DataSize = DataSize; 
00223     TransferInfo.TransferType = TransferType;
00224     TransferInfo.TransferID = m_NextTransferID;
00225     TransferInfo.DestTransferID = DestTransferID;
00226     
00227     // Tenta inserir a estrutura TransferInfo na hash usando a chave 
00228     // m_NextTransferID
00229     try
00230     {
00231         // Tenta inserir a estrutura na hash.
00232         m_TransferInfoHash[ m_NextTransferID ] = TransferInfo;
00233         
00234         // Armazena a ID atribuida a transferencia ao enderenco apontado por 
00235         // TransferID, se este ponteiro nao for NULL.
00236         if( TransferID != NULL )
00237             *TransferID = m_NextTransferID;
00238         
00239         // Como a insercao foi feita com sucesso, incrementa o contador 
00240         // m_NextTransferID para a proxima ID (para tentar sempre, no laco
00241         // acima para obter uma ID nao usada, evitar de usar a funcao find sobre
00242         // a hash por mais de uma vez.
00243         m_NextTransferID++;
00244     }
00245     catch( bad_alloc& ba )
00246     {
00247         // Coloca o identificador invalido no endereco apontado por TransferID,
00248         // se o valor do ponteiro nao for NULL, porque nao conseguimos colocar
00249         // a nova estrutura na hash.
00250         if( TransferID != NULL )
00251             *TransferID = NULLTRANSFERID;
00252 
00253         // Libera o acesso exclusivo as variaveis do objeto.
00254         pthread_mutex_unlock( &m_Mutex );
00255 
00256         #ifdef RIO_DEBUG2
00257         TRANSFERINFOLOG << "CTransferInfo::NewTransfer Erro de alocacao de "
00258                         << "memoria (bad_alloc, error = " << ba.what() << ") "
00259                         << "ao criar uma nova entrada na hash "
00260                         << "m_TransferInfoHash!" << endl;
00261         #endif
00262 
00263         #ifdef RIO_DEBUG1
00264         TRANSFERINFOLOG << "[CTransferInfo - NewTransfer] Finish1" << endl;
00265         #endif
00266        
00267         return ERROR_TRANSFERINFO + ERROR_MEMORY;
00268     } 
00269 
00270     #ifdef RIO_DEBUG2
00271     TRANSFERINFOLOG << "CTransferInfo::NewTransfer Uma nova transferencia com "
00272                     << "a ID " << m_NextTransferID - 1 << " foi criada com "
00273                     << "sucesso!" << endl;
00274     #endif
00275 
00276     // Libera o acesso exclusivo as variaveis do objeto.
00277     pthread_mutex_unlock( &m_Mutex );
00278 
00279     #ifdef RIO_DEBUG1
00280     TRANSFERINFOLOG << "[CTransferInfo - NewTransfer] Finish2" << endl;
00281     #endif
00282 
00283     return S_OK;
00284 }

RioResult CTransferInfo::RemoveTransfer ( TTransferID  TransferID  ) 

Funcao para remover uma estrutura de transferencia.

Parameters:
TransferID ID da transferencia a ser removida.
Returns:
S_OK se a estrutura da transferencia foi removida com sucesso, ou o codigo do erro caso algum erro tenha ocorrido.

Definition at line 287 of file NetInterface.cpp.

00288 {
00289     // Armazena um iterador para a hash.
00290     TTransferInfoHash::iterator HashTransfer;
00291 
00292     #ifdef RIO_DEBUG1
00293     TRANSFERINFOLOG << "[CTransferInfo - RemoveTransfer] Start" << endl;
00294     #endif
00295 
00296     // Obtem o acesso exclusivo as variaveis do objeto.
00297     pthread_mutex_lock( &m_Mutex );
00298     
00299     // Procura pelo identificador na hash.
00300     HashTransfer = FindTransferID( TransferID );
00301     if( HashTransfer == m_TransferInfoHash.end() )
00302     {
00303         // Libera o acesso exclusivo as variaveis do objeto.
00304         pthread_mutex_unlock( &m_Mutex );
00305         
00306         #ifdef RIO_DEBUG2
00307         TRANSFERINFOLOG << "CTransferInfo::RemoveTransfer O valor da ID "
00308                         << TransferID << " nao e valido!" << endl;
00309         #endif
00310 
00311         #ifdef RIO_DEBUG1
00312         TRANSFERINFOLOG << "[CTransferInfo - RemoveTransfer] Finish1" << endl;
00313         #endif
00314         
00315         return ERROR_TRANSFERINFO + ERROR_INVALID_PARAM;
00316     }
00317     
00318     // Remove a estrutura da hash.
00319     m_TransferInfoHash.erase( HashTransfer );
00320 
00321     #ifdef RIO_DEBUG2
00322     TRANSFERINFOLOG << "CTransferInfo::RemoveTransfer A transferencia com a ID "
00323                     << TransferID << " foi removida com sucesso!" << endl;
00324     #endif
00325 
00326     // Libera o acesso exclusivo as variaveis do objeto.
00327     pthread_mutex_unlock( &m_Mutex );
00328 
00329     #ifdef RIO_DEBUG1
00330     TRANSFERINFOLOG << "[CTransferInfo - RemoveTransfer] Finish2" << endl;
00331     #endif
00332     
00333     return S_OK;
00334 }

Field Documentation

pthread_mutex_t CTransferInfo::m_Mutex [private]

Definition at line 178 of file NetInterface.h.

CNetInterface* CTransferInfo::m_NetInterface [private]

Definition at line 168 of file NetInterface.h.

TTransferID CTransferInfo::m_NextTransferID [private]

Definition at line 171 of file NetInterface.h.

TTransferInfoHash CTransferInfo::m_TransferInfoHash [private]

Definition at line 175 of file NetInterface.h.

const TTransferID CTransferInfo::NullTransferID = -1 [static]

Definition at line 191 of file NetInterface.h.

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