Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 

NLNET::CNonBlockingBufSock Class Reference

#include <buf_sock.h>

Inheritance diagram for NLNET::CNonBlockingBufSock:

NLNET::CBufSock NLNET::CServerBufSock

Detailed Description

CNonBlockingBufSock A socket, its send buffer plus a nonblocking receiving system

Definition at line 273 of file buf_sock.h.

Public Member Functions

uint64 appId () const
 Returns the application identifier.

std::string asString () const
 Returns a string with the characteristics of the object.

void setAppId (uint64 id)
 Sets the application identifier.


Data Fields

std::string AuthorizedCallback
uint32 ReceiveNextValue
uint32 SendNextValue

Protected Member Functions

bool advertiseDisconnection (CBufNetBase *bnb, TSockId sockid)
bool advertiseSystemEvent (CBufNetBase *bnb, TSockId sockid, bool &flag, bool condition, CBufNetBase::TEventType event)
 CNonBlockingBufSock (CTcpSock *sock=NULL)
 Constructor.

void connect (const CInetAddress &addr, bool nodelay, bool connectedstate)
 Connects to the specified addr; set connectedstate to true if no connection advertising is needed.

bool connectedState () const
 Returns the "logically connected" state (changed when processing a connection/disconnection callback).

void disconnect (bool connectedstate)
 Disconnects; set connectedstate to false if no disconnection advertising is needed.

void fillEventTypeOnly ()
 Fill the event type byte at pos length()(for a client connection).

uint32 length () const
bool pushBuffer (const NLMISC::CMemStream &buffer)
const std::vector< uint8 > receivedBuffer () const
bool receivePart (uint32 nbExtraBytes)
void setConnectedState (bool connectedstate)
 Sets the "logically connected" state (changed when processing a connection/disconnection callback).

void setMaxExpectedBlockSize (sint32 limit)
 Set the size limit for received blocks.

void setNonBlocking ()
virtual std::string typeStr () const
 Returns "CLT " (client).


Protected Attributes

bool _KnowConnected
uint32 _MaxExpectedBlockSize
std::vector< uint8 > _ReceiveBuffer
NLMISC::CBufFIFO SendFifo
CTcpSock * Sock

Private Attributes

TBlockSize _BytesRead
TBlockSize _Length
bool _NowReadingBuffer

Friends

class CBufClient
class CBufServer
class CCallbackClient
class CCallbackNetBase
class CCallbackServer
class CClientReceiveTask
class CServerReceiveTask

Constructor & Destructor Documentation

NLNET::CNonBlockingBufSock::CNonBlockingBufSock (  CTcpSock *  sock = NULL  )  [protected]
 

Constructor.

Definition at line 356 of file buf_sock.cpp.

References nlnettrace. 

00356                                                          :
00357         CBufSock( sock ),
00358         _MaxExpectedBlockSize( 10485760 ), // 10M
00359         _NowReadingBuffer( false ),
00360         _BytesRead( 0 ),
00361         _Length( 0 )
00362 {
00363         nlnettrace( "CNonBlockingBufSock::CNonBlockingBufSock" );
00364 }

Member Function Documentation

bool NLNET::CBufSock::advertiseDisconnection (  CBufNetBase *  bnb,
TSockId  sockid
)  [inline, protected, inherited]
 

Pushes a disconnection message into bnb's receive queue, if it has not already been done (returns true in this case). You can either specify a sockid (for server) or InvalidSockId (for client)

Definition at line 120 of file buf_sock.h.

References NLNET::CBufSock::_KnowConnected, NLNET::CBufSock::advertiseSystemEvent(), nlassert, and NLNET::TSockId.

Referenced by NLNET::CBufClient::send(), and NLNET::CBufClient::update(). 

00121         {
00122 #ifdef NL_DEBUG
00123                 if ( sockid != InvalidSockId )
00124                 {
00125                         nlassert( sockid == this );
00126                 }
00127 #endif
00128                 return advertiseSystemEvent( bnb, sockid, _KnowConnected, true, CBufNetBase::Disconnection );
00129         }

bool NLNET::CBufSock::advertiseSystemEvent (  CBufNetBase *  bnb,
TSockId  sockid,
bool &  flag,
bool  condition,
CBufNetBase::TEventType  event
)  [inline, protected, inherited]
 

Pushes a system message into bnb's receive queue, if the flags meets the condition, then resets the flag and returns true. You can either specify a sockid (for server) or InvalidSockId (for client).

Definition at line 135 of file buf_sock.h.

References NLNET::CBufSock::asString(), buffer, condition, nlassert, nldebug, NLNET::CBufNetBase::pushMessageIntoReceiveQueue(), and NLNET::TSockId.

Referenced by NLNET::CServerBufSock::advertiseConnection(), and NLNET::CBufSock::advertiseDisconnection(). 

00137         {
00138 #ifdef NL_DEBUG
00139                 if ( sockid != InvalidSockId )
00140                 {
00141                         nlassert( sockid == this );
00142                 }
00143 #endif
00144                 // Test flag
00145                 if ( flag==condition )
00146                 {
00147                         nldebug( "LNETL1: Pushing event to %s", asString().c_str() );
00148                         std::vector<uint8> buffer;
00149                         if ( sockid == InvalidSockId )
00150                         {
00151                                 // Client: event type only
00152                                 buffer.resize( 1 );
00153                                 buffer[0] = event;
00154                         }
00155                         else
00156                         {
00157                                 // Server: sockid + event type
00158                                 buffer.resize( sizeof(TSockId) + 1 );
00159                                 memcpy( &*buffer.begin(), &sockid, sizeof(TSockId) );
00160                                 buffer[sizeof(TSockId)] = event;
00161                         }
00162                         // Push
00163                         bnb->pushMessageIntoReceiveQueue( buffer );
00164 
00165                         // Reset flag
00166                         flag = !condition;
00167                         return true;
00168                 }
00169                 else
00170                 {
00171                         return false;
00172                 }
00173         }

uint64 NLNET::CBufSock::appId (   )  const [inline, inherited]
 

Returns the application identifier.

Definition at line 63 of file buf_sock.h.

References NLNET::CBufSock::_AppId, and uint64.

Referenced by NLNET::CUnifiedNetwork::CUnifiedConnection::TConnection::getAppId(). 

00063 { return _AppId; }

string NLNET::CBufSock::asString (   )  const [inherited]
 

Returns a string with the characteristics of the object.

Definition at line 329 of file buf_sock.cpp.

References NLNET::CSock::descriptor(), NLNET::CBufSock::Sock, NLMISC::toString(), NLMISC::toStringPtr(), and NLNET::CBufSock::typeStr().

Referenced by NLNET::CBufSock::advertiseSystemEvent(), NLNET::CCallbackNetBase::authorizeOnly(), NLNET::CBufServer::dataAvailable(), NLNET::CBufSock::flush(), NLNET::CCallbackNetBase::processOneMessage(), receivePart(), NLNET::CServerReceiveTask::run(), NLNET::CListenTask::run(), NLNET::CNetManager::send(), and NLNET::CCallbackServer::sendAllMyAssociations(). 

00330 {
00331 //      stringstream ss;
00332         string str;
00333         if (this == InvalidSockId) // tricky
00334                 str = "<null>";
00335         else
00336         {
00337                 // if it crashs here, it means that the CBufSock was deleted and you try to access to the virtual table that is empty
00338                 // because the object is destroyed.
00339                 str += typeStr();
00340                 str += NLMISC::toStringPtr(this) + " (socket ";
00341                 
00342                 if (Sock == NULL)
00343                         str += "<null>";
00344                 else
00345                         str += NLMISC::toString(Sock->descriptor());
00346 
00347                 str += ")";
00348         }
00349         return str;
00350 }

void NLNET::CBufSock::connect (  const CInetAddress &  addr,
bool  nodelay,
bool  connectedstate
)  [protected, inherited]
 

Connects to the specified addr; set connectedstate to true if no connection advertising is needed.

Definition at line 295 of file buf_sock.cpp.

References NLNET::CBufSock::_ConnectedState, NLNET::CBufSock::_KnowConnected, addr, NLNET::CTcpSock::connect(), NLNET::CSock::connected(), nlassert, NLNET::CBufSock::ReceiveNextValue, NLNET::CBufSock::SendNextValue, NLNET::CTcpSock::setNoDelay(), and NLNET::CBufSock::Sock.

Referenced by NLNET::CCallbackClient::connect(), and NLNET::CBufClient::connect(). 

00296 {
00297         nlassert (this != InvalidSockId);       // invalid bufsock
00298         nlassert( ! Sock->connected() );
00299 
00300         SendNextValue = ReceiveNextValue = 0;
00301         
00302         Sock->connect( addr );
00303         _ConnectedState = connectedstate;
00304         _KnowConnected = connectedstate;
00305         if ( nodelay )
00306         {
00307                 Sock->setNoDelay( true );
00308         }
00309 }

bool NLNET::CBufSock::connectedState (   )  const [inline, protected, inherited]
 

Returns the "logically connected" state (changed when processing a connection/disconnection callback).

Definition at line 237 of file buf_sock.h.

References NLNET::CBufSock::_ConnectedState.

Referenced by NLNET::CBufClient::connected(), NLNET::CCallbackClient::disconnect(), NLNET::CBufClient::disconnect(), and NLNET::CBufClient::~CBufClient(). 

00237 { return _ConnectedState; }

void NLNET::CBufSock::disconnect (  bool  connectedstate  )  [protected, inherited]
 

Disconnects; set connectedstate to false if no disconnection advertising is needed.

Definition at line 315 of file buf_sock.cpp.

References NLNET::CBufSock::_ConnectedState, NLNET::CBufSock::_KnowConnected, NLNET::CTcpSock::disconnect(), nlassert, NLNET::CBufSock::ReceiveNextValue, NLNET::CBufSock::SendNextValue, and NLNET::CBufSock::Sock.

Referenced by NLNET::CBufClient::disconnect(). 

00316 {
00317         nlassert (this != InvalidSockId);       // invalid bufsock
00318         Sock->disconnect();
00319         _ConnectedState = connectedstate;
00320         _KnowConnected = connectedstate;
00321 
00322         SendNextValue = ReceiveNextValue = 0;
00323 }

void NLNET::CNonBlockingBufSock::fillEventTypeOnly (   )  [inline, protected]
 

Fill the event type byte at pos length()(for a client connection).

Definition at line 298 of file buf_sock.h.

References _ReceiveBuffer, and uint8.

Referenced by NLNET::CClientReceiveTask::run(). 

00298 { _ReceiveBuffer[_Length] = (uint8)CBufNetBase::User; }

bool NLNET::CBufSock::flush (   )  [protected, inherited]
 

Forces to send all data pending in the send queue

Returns:
False if an error has occured (e.g. the remote host is disconnected). To retrieve the reason of the error, call CSock::getLastError() and/or CSock::errorString()

Definition at line 137 of file buf_sock.cpp.

References NLNET::CBufSock::_ReadyToSendBuffer, NLNET::CBufSock::_RTSBIndex, NLNET::CBufSock::asString(), NLMISC::CObjectVector< uint8 >::clear(), NLMISC::CBufFIFO::empty(), NLMISC::CBufFIFO::front(), NLMISC::CObjectVector< uint8 >::getPtr(), len, nlassert, nlassertex, nldebug, NLMISC::CBufFIFO::pop(), res, NLMISC::CObjectVector< uint8 >::resize(), NLNET::CSock::send(), NLNET::CBufSock::SendFifo, NLMISC::CObjectVector< uint8 >::size(), size, NLNET::CBufSock::Sock, NLNET::TBlockSize, uint, uint32, and uint8.

Referenced by NLNET::CBufServer::disconnect(), NLNET::CBufClient::disconnect(), NLNET::CBufServer::flush(), NLNET::CBufClient::flush(), and NLNET::CBufSock::update(). 

00138 {
00139         nlassert (this != InvalidSockId);       // invalid bufsock
00140         //nlnettrace( "CBufSock::flush" );
00141 
00142         // Copy data from the send queue to _ReadyToSendBuffer
00143         TBlockSize netlen;
00144 //      vector<uint8> tmpbuffer;
00145 
00146         // Process each element in the send queue
00147         while ( ! SendFifo.empty() )
00148         {
00149                 uint8 *tmpbuffer;
00150                 uint32 size;
00151                 SendFifo.front( tmpbuffer, size );
00152 
00153                 // Compute the size and add it into the beginning of the buffer
00154                 netlen = htonl( (TBlockSize)size );
00155                 uint32 oldBufferSize = _ReadyToSendBuffer.size();
00156                 _ReadyToSendBuffer.resize (oldBufferSize+sizeof(TBlockSize)+size);
00157                 *(TBlockSize*)&(_ReadyToSendBuffer[oldBufferSize])=netlen;
00158                 //nldebug( "O-%u %u+L%u (0x%x)", Sock->descriptor(), oldBufferSize, size, size );
00159 
00160 
00161                 // Append the temporary buffer to the global buffer
00162                 CFastMem::memcpy (&_ReadyToSendBuffer[oldBufferSize+sizeof(TBlockSize)], tmpbuffer, size);
00163                 SendFifo.pop();
00164         }
00165 
00166         // Actual sending of _ReadyToSendBuffer
00167         //if ( ! _ReadyToSendBuffer.empty() )
00168         if ( _ReadyToSendBuffer.size() != 0 )
00169         {               
00170                 // Send
00171                 CSock::TSockResult res;
00172                 TBlockSize len = _ReadyToSendBuffer.size() - _RTSBIndex;
00173 
00174                 res = Sock->send( _ReadyToSendBuffer.getPtr()+_RTSBIndex, len, false );
00175 
00176                 if ( res == CSock::Ok )
00177                 {
00178 /*                      // Debug display
00179                         switch ( _FlushTrigger )
00180                         {
00181                         case FTTime : nldebug( "LNETL1: Time triggered flush for %s:", asString().c_str() ); break;
00182                         case FTSize : nldebug( "LNETL1: Size triggered flush for %s:", asString().c_str() ); break;
00183                         default:          nldebug( "LNETL1: Manual flush for %s:", asString().c_str() );
00184                         }
00185                         _FlushTrigger = FTManual;
00186                         nldebug( "LNETL1: %s sent effectively a buffer (%d on %d B)", asString().c_str(), len, _ReadyToSendBuffer.size() );
00187 */                      
00188                         
00189                         // TODO OPTIM remove the nldebug for speed
00190                         //commented for optimisation nldebug( "LNETL1: %s sent effectively %u/%u bytes (pos %u wantedsend %u)", asString().c_str(), len, _ReadyToSendBuffer.size(), _RTSBIndex, realLen/*, stringFromVectorPart(_ReadyToSendBuffer,_RTSBIndex,len).c_str()*/ );
00191 
00192                         if ( _RTSBIndex+len == _ReadyToSendBuffer.size() ) // for non-blocking mode
00193                         {
00194                                 // If sending is ok, clear the global buffer
00195                                 //nldebug( "O-%u all %u bytes (%u to %u) sent", Sock->descriptor(), len, _RTSBIndex, _ReadyToSendBuffer.size() );
00196                                 _ReadyToSendBuffer.clear();
00197                                 _RTSBIndex = 0;
00198                         }
00199                         else
00200                         {
00201                                 // Or clear only the data that was actually sent
00202                                 nlassertex( _RTSBIndex+len < _ReadyToSendBuffer.size(), ("index=%u len=%u size=%u", _RTSBIndex, len, _ReadyToSendBuffer.size()) );
00203                                 //nldebug( "O-%u only %u B on %u (%u to %u) sent", Sock->descriptor(), len, _ReadyToSendBuffer.size()-_RTSBIndex, _RTSBIndex, _ReadyToSendBuffer.size() );
00204                                 _RTSBIndex += len;
00205                                 if ( _ReadyToSendBuffer.size() > 20480 ) // if big, clear data already sent
00206                                 {
00207                                         uint nbcpy = _ReadyToSendBuffer.size() - _RTSBIndex;
00208                                         for (uint i = 0; i < nbcpy; i++)
00209                                         {
00210                                                 _ReadyToSendBuffer[i] = _ReadyToSendBuffer[i+_RTSBIndex];
00211                                         }
00212                                         _ReadyToSendBuffer.resize(nbcpy);
00213                                         //_ReadyToSendBuffer.erase( _ReadyToSendBuffer.begin(), _ReadyToSendBuffer.begin()+_RTSBIndex );
00214                                         _RTSBIndex = 0;
00215                                         //nldebug( "O-%u Cleared data already sent, %u B remain", Sock->descriptor(), nbcpy );
00216                                 }
00217                         }
00218                 }
00219                 else
00220                 {
00221 #ifdef NL_DEBUG
00222                         // can happen in a normal behavior if, for example, the other side is not connected anymore
00223                         nldebug( "LNETL1: %s failed to send effectively a buffer of %d bytes", asString().c_str(), _ReadyToSendBuffer.size() );
00224 #endif
00225                         return false;
00226                 }
00227         }
00228 
00229         return true;
00230 }

uint32 NLNET::CNonBlockingBufSock::length (   )  const [inline, protected]
 

Return the length of the received block (call after receivePart() returns true). The total size of received buffer is length() + nbExtraBytes (passed to receivePart()).

Definition at line 303 of file buf_sock.h.

References uint32.

Referenced by NLNET::CServerBufSock::fillSockIdAndEventType(). 

00303 { return _Length; }

bool NLNET::CBufSock::pushBuffer (  const NLMISC::CMemStream &  buffer  )  [inline, protected, inherited]
 

Pushes a buffer to the send queue and update, or returns false if the socket is not physically connected the or an error occured during sending

Definition at line 178 of file buf_sock.h.

References buffer, NLNET::CSock::connected(), nlassert, nlwarning, NLMISC::CBufFIFO::push(), res, NLNET::CBufSock::SendFifo, NLNET::CBufSock::Sock, uint32, and NLNET::CBufSock::update().

Referenced by NLNET::CBufServer::pushBufferToHost(), and NLNET::CBufClient::send(). 

00179         {
00180                 nlassert (this != InvalidSockId);       // invalid bufsock
00181 //              nldebug( "LNETL1: Pushing buffer to %s", asString().c_str() );
00182 
00183                 static uint32 biggerBufferSize = 64000;
00184                 if (buffer.length() > biggerBufferSize)
00185                 {
00186                         biggerBufferSize = buffer.length();
00187                         nlwarning ("LNETL1: new record! bigger network message pushed (sent) is %u bytes", biggerBufferSize);
00188                 }
00189 
00190                 if ( Sock->connected() )
00191                 {
00192                         // Push into host's send queue
00193                         SendFifo.push( buffer );
00194 
00195                         // Update sending
00196                         bool res = update ();
00197                         return res; // not checking the result as in CBufServer::update()
00198                 }
00199                 return false;
00200         }

const std::vector<uint8> NLNET::CNonBlockingBufSock::receivedBuffer (   )  const [inline, protected]
 

Returns the filled buffer (call after receivePart() returns true). Its size is length()+1.

Definition at line 308 of file buf_sock.h.

References _ReceiveBuffer, and nlnettrace.

Referenced by NLNET::CServerReceiveTask::run(), and NLNET::CClientReceiveTask::run(). 

00308 { nlnettrace( "CServerBufSock::receivedBuffer" ); return _ReceiveBuffer; }

bool NLNET::CNonBlockingBufSock::receivePart (  uint32  nbExtraBytes  )  [protected]
 

Receives a part of a message (nonblocking socket only)

Parameters:
nbExtraBytes Number of bytes to reserve for extra information such as the event type
Returns:
True if the message has been completely received

Definition at line 386 of file buf_sock.cpp.

References _BytesRead, _NowReadingBuffer, _ReceiveBuffer, NLNET::CInetAddress::asString(), NLNET::CBufSock::asString(), nlassert, nldebug, nlnettrace, nlwarning, NLNET::CSock::receive(), NLNET::CSock::remoteAddr(), NLMISC::stringFromVector(), NLNET::TBlockSize, NLMISC::toString(), uint32, and uint8.

Referenced by NLNET::CServerReceiveTask::run(), and NLNET::CClientReceiveTask::run(). 

00387 {
00388         nlassert (this != InvalidSockId);       // invalid bufsock
00389         nlnettrace( "CNonBlockingBufSock::receivePart" );
00390 
00391         TBlockSize actuallen;
00392         if ( ! _NowReadingBuffer )
00393         {
00394                 // Receiving length prefix
00395                 actuallen = sizeof(_Length)-_BytesRead;
00396                 Sock->receive( (uint8*)(&_Length)+_BytesRead, actuallen );
00397                 _BytesRead += actuallen;
00398                 if ( _BytesRead == sizeof(_Length ) )
00399                 {
00400                         if ( _Length != 0 )
00401                         {
00402                                 _Length = ntohl( _Length );
00403                                 //nldebug( "I-%u L%u (0x%x) a%u", Sock->descriptor(), _Length, _Length, actuallen );
00404 
00405                                 // Test size limit
00406                                 if ( _Length > _MaxExpectedBlockSize )
00407                                 {
00408                                         nlwarning( "LNETL1: Socket %s received header length %u exceeding max expected %u... Disconnecting", asString().c_str(), _Length, _MaxExpectedBlockSize );
00409                                         throw ESocket( toString( "Received length %u exceeding max expected %u from %s", _Length, _MaxExpectedBlockSize, Sock->remoteAddr().asString().c_str() ).c_str(), false );
00410                                 }
00411 
00412                                 _NowReadingBuffer = true;
00413                                 _ReceiveBuffer.resize( _Length + nbExtraBytes );
00414                         }
00415                         else
00416                         {
00417                                 nlwarning( "LNETL1: Socket %s received null length in block header", asString().c_str() );
00418                         }
00419                         _BytesRead = 0;
00420                 }
00421         }
00422 
00423         if ( _NowReadingBuffer )
00424         {
00425                 // Receiving payload buffer
00426                 actuallen = _Length-_BytesRead;
00427                 Sock->receive( &*_ReceiveBuffer.begin()+_BytesRead, actuallen );
00428                 _BytesRead += actuallen;
00429 
00430                 if ( _BytesRead == _Length )
00431                 {
00432 #ifdef NL_DEBUG
00433                         nldebug( "LNETL1: %s received buffer (%u bytes): [%s]", asString().c_str(), _ReceiveBuffer.size(), stringFromVector(_ReceiveBuffer).c_str() );
00434 #endif
00435                         _NowReadingBuffer = false;
00436                         //nldebug( "I-%u all %u B on %u", Sock->descriptor(), actuallen );
00437                         _BytesRead = 0;
00438                         return true;
00439                 }
00440                 //else
00441                 //{
00442                 //      nldebug( "I-%u only %u B on %u", actuallen, Sock->descriptor(), _Length-(_BytesRead-actuallen) );
00443                 //}
00444         }
00445 
00446         return false;
00447 }

void NLNET::CBufSock::setAppId (  uint64  id  )  [inline, inherited]
 

Sets the application identifier.

Definition at line 60 of file buf_sock.h.

References NLNET::CBufSock::_AppId, and uint64.

Referenced by NLNET::CUnifiedNetwork::addService(), NLNET::CPacsClient::connect(), and NLNET::CUnifiedNetwork::CUnifiedConnection::TConnection::setAppId(). 

00060 { _AppId = id; }

void NLNET::CBufSock::setConnectedState (  bool  connectedstate  )  [inline, protected, inherited]
 

Sets the "logically connected" state (changed when processing a connection/disconnection callback).

Definition at line 234 of file buf_sock.h.

References NLNET::CBufSock::_ConnectedState.

Referenced by NLNET::CBufServer::dataAvailable(), and NLNET::CBufClient::dataAvailable(). 

00234 { _ConnectedState = connectedstate; }

void NLNET::CNonBlockingBufSock::setMaxExpectedBlockSize (  sint32  limit  )  [inline, protected]
 

Set the size limit for received blocks.

Definition at line 289 of file buf_sock.h.

References sint32.

Referenced by NLNET::CBufClient::connect(), and NLNET::CListenTask::run(). 

00289 { _MaxExpectedBlockSize = limit; }

void NLNET::CNonBlockingBufSock::setNonBlocking (   )  [inline, protected]
 

Call this method after connecting (for a client connection) to set the non-blocking mode. For a server connection, call it as soon as the object is constructed

Definition at line 286 of file buf_sock.h.

References NLNET::CSock::setNonBlockingMode().

Referenced by NLNET::CBufClient::connect(), and NLNET::CListenTask::run(). 

00286 { Sock->setNonBlockingMode( true ); }

void NLNET::CBufSock::setSizeFlushTrigger (  sint32  size  )  [inline, protected, inherited]
 

Sets the size flush trigger. When the size of the send queue reaches or exceeds this calue, all data in the send queue is automatically sent (-1 to disable this trigger )

Definition at line 104 of file buf_sock.h.

References NLNET::CBufSock::_TriggerSize, sint32, and size.

Referenced by NLNET::CBufServer::setSizeFlushTrigger(), and NLNET::CBufClient::setSizeFlushTrigger(). 

00104 { _TriggerSize = size; }

void NLNET::CBufSock::setTimeFlushTrigger (  sint32  ms  )  [protected, inherited]
 

Sets the time flush trigger (in millisecond). When this time is elapsed, all data in the send queue is automatically sent (-1 to disable this trigger)

Definition at line 236 of file buf_sock.cpp.

References NLNET::CBufSock::_LastFlushTime, NLNET::CBufSock::_TriggerTime, nlassert, and sint32.

Referenced by NLNET::CBufServer::setTimeFlushTrigger(), and NLNET::CBufClient::setTimeFlushTrigger(). 

00237 {
00238         nlassert (this != InvalidSockId);       // invalid bufsock
00239         _TriggerTime = ms;
00240         _LastFlushTime = CTime::getLocalTime();
00241 }

virtual std::string NLNET::CBufSock::typeStr (   )  const [inline, protected, virtual, inherited]
 

Returns "CLT " (client).

Reimplemented in NLNET::CServerBufSock.

Definition at line 115 of file buf_sock.h.

Referenced by NLNET::CBufSock::asString(). 

00115 { return "CLT "; }

bool NLNET::CBufSock::update (   )  [protected, inherited]
 

Update the network sending (call this method evenly). Returns false if an error occured.

Definition at line 247 of file buf_sock.cpp.

References NLNET::CBufSock::_LastFlushTime, NLNET::CBufSock::_TriggerSize, NLNET::CBufSock::_TriggerTime, NLNET::CBufSock::flush(), nlassert, NLNET::CBufSock::SendFifo, sint32, NLMISC::CBufFIFO::size(), and NLMISC::TTime.

Referenced by NLNET::CBufSock::pushBuffer(), and NLNET::CBufClient::update(). 

00248 {
00249         nlassert (this != InvalidSockId);       // invalid bufsock
00250 //      nlnettrace( "CBufSock::update-BEGIN" );
00251         // Time trigger
00252 
00253         if ( _TriggerTime != -1 )
00254         {
00255                 TTime now = CTime::getLocalTime();
00256                 if ( (sint32)(now-_LastFlushTime) >= _TriggerTime )
00257                 {
00258 #ifdef NL_DEBUG
00259                         _FlushTrigger = FTTime;
00260 #endif
00261                         if ( flush() )
00262                         {
00263                                 _LastFlushTime = now;
00264 //                              nlnettrace ( "CBufSock::update-END time 1" );
00265                                 return true;
00266                         }
00267                         else
00268                         {
00269 //                              nlnettrace ( "CBufSock::update-END time 0" );
00270                                 return false;
00271                         }
00272                 }
00273         }
00274         // Size trigger
00275         if ( _TriggerSize != -1 )
00276         {
00277                 if ( (sint32)SendFifo.size() > _TriggerSize )
00278                 {
00279 #ifdef NL_DEBUG
00280                         _FlushTrigger = FTSize;
00281 #endif
00282 //                      nlnettrace( "CBufSock::update-END size" );
00283                         return flush();
00284                 }
00285         }
00286 //      nlnettrace( "CBufSock::update-END nosend" );
00287         return true;
00288 }

Friends And Related Function Documentation

friend class CBufClient [friend]
 

Reimplemented from NLNET::CBufSock.

Definition at line 277 of file buf_sock.h.

friend class CBufServer [friend, inherited]
 

Reimplemented in NLNET::CServerBufSock.

Definition at line 79 of file buf_sock.h.

friend class CCallbackClient [friend, inherited]
 

Definition at line 83 of file buf_sock.h.

friend class CCallbackNetBase [friend, inherited]
 

Definition at line 85 of file buf_sock.h.

friend class CCallbackServer [friend, inherited]
 

Definition at line 84 of file buf_sock.h.

friend class CClientReceiveTask [friend]
 

Reimplemented from NLNET::CBufSock.

Definition at line 278 of file buf_sock.h.

friend class CServerReceiveTask [friend, inherited]
 

Reimplemented in NLNET::CServerBufSock.

Definition at line 81 of file buf_sock.h.

Field Documentation

TBlockSize NLNET::CNonBlockingBufSock::_BytesRead [private]
 

Definition at line 322 of file buf_sock.h.

Referenced by receivePart().

bool NLNET::CBufSock::_KnowConnected [protected, inherited]
 

Definition at line 246 of file buf_sock.h.

Referenced by NLNET::CBufSock::advertiseDisconnection(), NLNET::CBufSock::connect(), NLNET::CBufSock::disconnect(), and NLNET::CBufSock::~CBufSock().

TBlockSize NLNET::CNonBlockingBufSock::_Length [private]
 

Definition at line 325 of file buf_sock.h.

uint32 NLNET::CNonBlockingBufSock::_MaxExpectedBlockSize [protected]
 

Definition at line 314 of file buf_sock.h.

bool NLNET::CNonBlockingBufSock::_NowReadingBuffer [private]
 

Definition at line 319 of file buf_sock.h.

Referenced by receivePart().

std::vector<uint8> NLNET::CNonBlockingBufSock::_ReceiveBuffer [protected]
 

Definition at line 311 of file buf_sock.h.

Referenced by fillEventTypeOnly(), receivedBuffer(), and receivePart().

std::string NLNET::CBufSock::AuthorizedCallback [inherited]
 

Little tricky but this string is used by Layer4 to know which callback is authorized. This is empty when all callback are authorized.

Definition at line 70 of file buf_sock.h.

Referenced by NLNET::CCallbackNetBase::authorizeOnly(), NLNET::CCallbackNetBase::processOneMessage(), and NLNET::CBufSock::~CBufSock().

uint32 NLNET::CBufSock::ReceiveNextValue [inherited]
 

Definition at line 74 of file buf_sock.h.

Referenced by NLNET::CBufSock::connect(), and NLNET::CBufSock::disconnect().

NLMISC::CBufFIFO NLNET::CBufSock::SendFifo [protected, inherited]
 

Definition at line 240 of file buf_sock.h.

Referenced by NLNET::CBufServer::displaySendQueueStat(), NLNET::CBufClient::displaySendQueueStat(), NLNET::CBufSock::flush(), NLNET::CBufServer::getSendQueueSize(), NLNET::CBufClient::getSendQueueSize(), NLNET::CBufSock::pushBuffer(), and NLNET::CBufSock::update().

uint32 NLNET::CBufSock::SendNextValue [inherited]
 

Definition at line 74 of file buf_sock.h.

Referenced by NLNET::CBufSock::connect(), NLNET::CBufSock::disconnect(), and NLNET::CBufServer::send().

CTcpSock* NLNET::CBufSock::Sock [protected, inherited]
 

Definition at line 243 of file buf_sock.h.

Referenced by NLNET::CBufSock::asString(), NLNET::CBufClient::bytesDownloaded(), NLNET::CBufClient::bytesUploaded(), NLNET::CBufSock::CBufSock(), NLNET::CCallbackClient::connect(), NLNET::CBufSock::connect(), NLNET::CBufClient::connect(), NLNET::CBufSock::disconnect(), NLNET::CBufServer::disconnect(), NLNET::CBufClient::disconnect(), NLNET::CBufSock::flush(), NLNET::CBufServer::hostAddress(), NLNET::CBufSock::pushBuffer(), NLNET::CBufClient::remoteAddress(), NLNET::CListenTask::run(), NLNET::CClientReceiveTask::run(), NLNET::CBufClient::update(), NLNET::CBufClient::~CBufClient(), and NLNET::CBufSock::~CBufSock().

The documentation for this class was generated from the following files:
Generated on Tue Mar 16 14:02:18 2004 for NeL by doxygen 1.3.6