CSocketPool Class Reference#include <SocketPool.h>
Inheritance diagram for CSocketPool:
![]()
Collaboration diagram for CSocketPool:
![]()
Detailed DescriptionDefinition at line 45 of file SocketPool.h. Member Typedef Documentation
Definition at line 51 of file SocketPool.h.
Constructor & Destructor Documentation
Definition at line 38 of file SocketPool.cpp. 00040 : CErrorHandler(), 00041 m_iMaxSocket(iMaxSockets), 00042 m_pAllocator(pAllocator), 00043 m_pCSection(NULL), 00044 m_pCSectionQueue(NULL), 00045 m_iActiveSockets(0), 00046 m_bClosing(FALSE), 00047 m_iMaxBackQueue(iMaxQueue) 00048 { 00049 try 00050 { 00051 //Set our name 00052 SetName(CSocketPool_Class); 00053 00054 //Create the CS 00055 m_pCSection=COSManager::CreateCriticalSection(); 00056 m_pCSectionQueue=COSManager::CreateCriticalSection(); 00057 } 00058 ERROR_HANDLER("CSocketPool") 00059 }
Definition at line 61 of file SocketPool.cpp. 00062 { 00063 try 00064 { 00065 //Clear the queue 00066 Clear(); 00067 00068 //Delete the CS 00069 delete m_pCSection; 00070 delete m_pCSectionQueue; 00071 } 00072 ERROR_HANDLER("~CSocketPool") 00073 }
Member Function Documentation
Definition at line 680 of file ErrorHandler.cpp. 00681 { 00682 //Delete the logs 00683 delete m_pSecondLevelLog; 00684 m_pSecondLevelLog=NULL; 00685 00686 delete m_pThirdLevelLog; 00687 m_pThirdLevelLog=NULL; 00688 }
Definition at line 140 of file SocketPool.cpp. 00143 { 00144 try 00145 { 00146 //Protect the socket 00147 std::auto_ptr<CSocketPoolSocket> pProtection(pSocket); 00148 00149 //Are we closing 00150 if (m_bClosing) 00151 return TRUE; 00152 00153 //Set the connection data 00154 pSocket->SetConnectionData(rAddress, 00155 usPort); 00156 00157 //Lock the CSection 00158 CCriticalAutoRelease aRelease(m_pCSection); 00159 00160 //Do we have enough space 00161 if (m_iActiveSockets>=m_iMaxSocket) 00162 { 00163 //Can we add to queue 00164 if (m_aQueue.size()>m_iMaxBackQueue) 00165 return FALSE; 00166 00167 //Add the data to the queue 00168 m_aQueue.push_back(pSocket); 00169 00170 //Release the protection 00171 pProtection.release(); 00172 00173 //Exit 00174 return TRUE; 00175 } 00176 00177 //Get the socket 00178 ++m_iActiveSockets; 00179 00180 //Exit the CS 00181 aRelease.Exit(); 00182 00183 //Try to connect 00184 if (!pSocket->Connect()) 00185 { 00186 //Check the reconnect 00187 CheckQueue(); 00188 00189 //Exit 00190 return FALSE; 00191 } 00192 else 00193 { 00194 //Release the protection 00195 pProtection.release(); 00196 00197 //Exit 00198 return TRUE; 00199 } 00200 } 00201 ERROR_HANDLER_RETURN("Connect",FALSE) 00202 }
Definition at line 111 of file SocketPool.cpp. 00113 { 00114 try 00115 { 00116 //Allocate the socket 00117 CSocketPoolSocket* pSocket; 00118 00119 //Do we have an allocator? 00120 if (!m_pAllocator) 00121 { 00122 //Report it 00123 ReportError("Connect","No allocator!"); 00124 00125 //Exit 00126 return FALSE; 00127 } 00128 00129 //Allocate it 00130 pSocket=(*m_pAllocator)(this); 00131 00132 //Try to connect 00133 return Connect(rAddress, 00134 usPort, 00135 pSocket); 00136 } 00137 ERROR_HANDLER_RETURN("Connect",FALSE) 00138 }
Definition at line 251 of file ErrorHandler.cpp. 00252 { 00253 try 00254 { 00255 //Try to look it in the errors 00256 if (!CErrorsRepository::GetInstance().GetErrorsMap().empty()) 00257 { 00258 //Search 00259 CErrorsRepository::ErrorMap::const_iterator aIterator; 00260 aIterator=CErrorsRepository::GetInstance().GetErrorsMap().find(dwErrorCode); 00261 00262 //Do we have it 00263 if (aIterator!=CErrorsRepository::GetInstance().GetErrorsMap().end()) 00264 return aIterator->second; 00265 } 00266 00267 //Get the error string 00268 LPVOID lpMsgBuf; 00269 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 00270 FORMAT_MESSAGE_FROM_SYSTEM | 00271 FORMAT_MESSAGE_IGNORE_INSERTS, 00272 NULL, 00273 dwErrorCode, 00274 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language 00275 (LPTSTR) &lpMsgBuf, 00276 0, 00277 NULL); 00278 00279 //Save it 00280 std::string sMessage; 00281 00282 //Do we have the message? 00283 if (lpMsgBuf) 00284 { 00285 //Save it 00286 sMessage=(char*)lpMsgBuf; 00287 00288 //Release the buffer 00289 LocalFree(lpMsgBuf); 00290 } 00291 else 00292 //Failed to find 00293 sMessage="No error description found!"; 00294 00295 //Done 00296 return sMessage; 00297 } 00298 catch (...) 00299 { 00300 return "Unknown"; 00301 } 00302 }
Definition at line 145 of file ErrorHandler.cpp. 00149 { 00150 //Our message 00151 std::string sMsg; 00152 00153 //Is it an error? 00154 if (bError) 00155 sMsg="*** Error *** "; 00156 else 00157 sMsg="### Msg ### "; 00158 00159 //Add the data now 00160 sMsg+="in "+rClass; 00161 sMsg+="::"+rMethod; 00162 sMsg+=" - " + rMsgOrError; 00163 00164 //Done 00165 return sMsg; 00166 }
Definition at line 622 of file ErrorHandler.cpp. 00623 { 00624 try 00625 { 00626 //Our string 00627 std::string sDate; 00628 00629 //Our tmp buf 00630 char cTmp[128]; 00631 00632 //Get date 00633 _strdate(cTmp); 00634 sDate=cTmp; 00635 sDate+=' '; 00636 00637 //Get time 00638 _strtime(cTmp); 00639 sDate+=cTmp; 00640 00641 //Done 00642 return sDate; 00643 } 00644 ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","") 00645 }
Definition at line 658 of file ErrorHandler.cpp. 00659 { 00660 //Do we have log 00661 if (!m_pSecondLevelLog) 00662 //Create it 00663 m_pSecondLevelLog=new CErrorHandler; 00664 00665 //Return it 00666 return m_pSecondLevelLog; 00667 }
Definition at line 669 of file ErrorHandler.cpp. 00670 { 00671 //Do we have log 00672 if (!m_pThirdLevelLog) 00673 //Create it 00674 m_pThirdLevelLog=new CErrorHandler; 00675 00676 //Return it 00677 return m_pThirdLevelLog; 00678 }
Definition at line 647 of file ErrorHandler.cpp. 00649 { 00650 try 00651 { 00652 //Add the error 00653 CErrorsRepository::GetInstance().GetErrorsMap().insert(CErrorsRepository::ErrorMap::value_type(dwErrorCode,rDescription)); 00654 } 00655 ERROR_HANDLER_STATIC(CErrorHandler_Class,"RegisterError") 00656 }
Definition at line 304 of file ErrorHandler.cpp. 00307 { 00308 if (!GetLog()) 00309 return; 00310 00311 try 00312 { 00313 //Convert the error code 00314 char aTmp[11]; 00315 sprintf(aTmp,"%d",iErrorCode); 00316 00317 //Get the string for it 00318 std::string sError; 00319 sError=rMessage; 00320 sError+=", and Socket error: "; 00321 sError+=aTmp; 00322 sError+=", "; 00323 sError+=ErrorCodeToString(iErrorCode); 00324 00325 //Report to the log 00326 WriteError(m_sClassName, 00327 rMethod, 00328 sError); 00329 } 00330 ERROR_UNKNOWN("ReportError") 00331 }
Definition at line 333 of file ErrorHandler.cpp. 00335 { 00336 if (!GetLog()) 00337 return; 00338 00339 try 00340 { 00341 //Convert the error code 00342 char aTmp[11]; 00343 sprintf(aTmp,"%d",iErrorCode); 00344 00345 //Get the string for it 00346 std::string sError; 00347 sError="Socket error: "; 00348 sError+=aTmp; 00349 sError+=", "; 00350 sError+=ErrorCodeToString(iErrorCode); 00351 00352 //Report to the log 00353 WriteError(m_sClassName, 00354 rMethod, 00355 sError); 00356 } 00357 ERROR_UNKNOWN("ReportError") 00358 }
Definition at line 461 of file ErrorHandler.cpp. 00464 { 00465 if (!GetLog()) 00466 return; 00467 00468 try 00469 { 00470 //Create the new message 00471 std::string sNewMessage(rMessage); 00472 sNewMessage+=", Additional data: "; 00473 sNewMessage+=rAdditionalData; 00474 00475 //Report to the log 00476 WriteError(m_sClassName, 00477 rMethod, 00478 sNewMessage); 00479 } 00480 ERROR_UNKNOWN("ReportError") 00481 }
Definition at line 483 of file ErrorHandler.cpp. 00486 { 00487 if (!GetLog()) 00488 return; 00489 00490 try 00491 { 00492 //Convert the number 00493 char aTmp[11]; 00494 ltoa(dwAdditionalData,aTmp,10); 00495 00496 //Create the new message 00497 std::string sNewMessage(rMessage); 00498 sNewMessage+=", Additional data: "; 00499 sNewMessage+=aTmp; 00500 00501 //Report to the log 00502 WriteError(m_sClassName, 00503 rMethod, 00504 sNewMessage); 00505 } 00506 ERROR_UNKNOWN("ReportError") 00507 }
Definition at line 376 of file ErrorHandler.cpp. 00378 { 00379 if (!GetLog()) 00380 return; 00381 00382 try 00383 { 00384 //Report to the log 00385 WriteError(m_sClassName, 00386 rMethod, 00387 rMessage); 00388 } 00389 ERROR_UNKNOWN("ReportError") 00390 }
Definition at line 515 of file ErrorHandler.cpp. 00516 { 00517 if (!GetLog()) 00518 return; 00519 00520 try 00521 { 00522 //Get the last error 00523 DWORD dwLastError; 00524 dwLastError=GetLastError(); 00525 00526 //Report the error 00527 WriteError(m_sClassName, 00528 rMethod, 00529 ErrorCodeToString(dwLastError)); 00530 } 00531 ERROR_UNKNOWN("ReportError") 00532 }
Definition at line 427 of file ErrorHandler.cpp. 00429 { 00430 if (!GetLog()) 00431 return; 00432 00433 try 00434 { 00435 //Get the last error 00436 DWORD dwLastError; 00437 dwLastError=GetLastError(); 00438 00439 //Format the message 00440 std::string sMessage; 00441 sMessage=rMessage; 00442 sMessage+=", with error code: "; 00443 00444 //Convert the error code 00445 char aTmp[11]; 00446 itoa(dwLastError,aTmp,10); 00447 00448 //Add it again 00449 sMessage+=aTmp; 00450 sMessage+=" "; 00451 sMessage+=ErrorCodeToString(dwLastError); 00452 00453 //Report to the log 00454 WriteError(m_sClassName, 00455 rMethod, 00456 sMessage); 00457 } 00458 ERROR_UNKNOWN("ReportErrorOS") 00459 }
Definition at line 590 of file ErrorHandler.cpp. 00594 { 00595 if (!m_pLog) 00596 return; 00597 00598 try 00599 { 00600 //Convert the number 00601 char aTmp[11]; 00602 ltoa(dwAdditionalData,aTmp,10); 00603 00604 //Create the new message 00605 std::string sNewMessage(rMessage); 00606 sNewMessage+=", Additional data: "; 00607 sNewMessage+=aTmp; 00608 00609 //Report to the log 00610 WriteStaticError(rClass, 00611 rMethod, 00612 sNewMessage); 00613 } 00614 ERROR_UNKNOWN("ReportStaticError") 00615 }
Definition at line 573 of file ErrorHandler.cpp. 00576 { 00577 if (!m_pLog) 00578 return; 00579 00580 try 00581 { 00582 //Report to the log 00583 WriteStaticError(rClass, 00584 rMethod, 00585 rMessage); 00586 } 00587 ERROR_UNKNOWN("ReportStaticError") 00588 }
Definition at line 553 of file ErrorHandler.cpp. 00555 { 00556 if (!m_pLog) 00557 return; 00558 00559 try 00560 { 00561 //Get the last error 00562 DWORD dwLastError; 00563 dwLastError=GetLastError(); 00564 00565 //Report the error 00566 WriteStaticError(rClass, 00567 rMethod, 00568 ErrorCodeToString(dwLastError)); 00569 } 00570 ERROR_UNKNOWN("ReportStaticError") 00571 }
Definition at line 392 of file ErrorHandler.cpp. 00395 { 00396 if (!m_pLog) 00397 return; 00398 00399 try 00400 { 00401 //Get the last error 00402 DWORD dwLastError; 00403 dwLastError=GetLastError(); 00404 00405 //Format the message 00406 std::string sMessage; 00407 sMessage=rMessage; 00408 sMessage+=", with error code: "; 00409 00410 //Convert the error code 00411 char aTmp[11]; 00412 itoa(dwLastError,aTmp,10); 00413 00414 //Add it again 00415 sMessage+=aTmp; 00416 sMessage+=" "; 00417 sMessage+=ErrorCodeToString(dwLastError); 00418 00419 //Report to the log 00420 WriteStaticError(rClass, 00421 rMethod, 00422 sMessage); 00423 } 00424 ERROR_UNKNOWN("ReportStaticError") 00425 }
Definition at line 543 of file ErrorHandler.cpp. 00545 { 00546 //Save the log 00547 m_pLocalLog=pLog; 00548 00549 //Save the write to main flag 00550 m_bWriteToMain=bWriteToMain; 00551 }
Definition at line 168 of file ErrorHandler.cpp. 00171 { 00172 //Do we have a log? 00173 if (!GetLog()) 00174 return; 00175 00176 //Format the msg 00177 std::string sError; 00178 sError=FormatData(rClass, 00179 rMethod, 00180 rError); 00181 00182 //Write it 00183 GetLog()->WriteError(sError); 00184 00185 //Write to main 00186 if (m_bWriteToMain && 00187 m_pLog) 00188 //Write it 00189 m_pLog->WriteError(sError); 00190 }
Definition at line 360 of file ErrorHandler.cpp. 00362 { 00363 if (!GetLog()) 00364 return; 00365 00366 try 00367 { 00368 //Report to the log 00369 WriteMessage(m_sClassName, 00370 rMethod, 00371 rMessage); 00372 } 00373 ERROR_UNKNOWN("WriteMessage") 00374 }
Definition at line 226 of file ErrorHandler.cpp. 00229 { 00230 //Do we have a log? 00231 if (!GetLog()) 00232 return; 00233 00234 //Format the msg 00235 std::string sMsg; 00236 sMsg=FormatData(rClass, 00237 rMethod, 00238 rMessage, 00239 false); 00240 00241 //Write it 00242 GetLog()->WriteMessage(sMsg); 00243 00244 //Write to main 00245 if (m_bWriteToMain && 00246 m_pLog) 00247 //Write it 00248 m_pLog->WriteMessage(sMsg); 00249 }
Definition at line 192 of file ErrorHandler.cpp. 00195 { 00196 //Do we have a log? 00197 if (!m_pLog) 00198 return; 00199 00200 //Format the msg 00201 std::string sError; 00202 sError=FormatData(rClass, 00203 rMethod, 00204 rError); 00205 00206 //Write it 00207 m_pLog->WriteError(sError); 00208 }
Definition at line 210 of file ErrorHandler.cpp. 00213 { 00214 //Do we have a log? 00215 if (!m_pLog) 00216 return; 00217 00218 //Format the msg 00219 std::string sMsg; 00220 sMsg=FormatData(rClass, 00221 rMethod, 00222 rMessage, 00223 false); 00224 }
Friends And Related Function Documentation
Definition at line 47 of file SocketPool.h.
The documentation for this class was generated from the following files: |