From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02303.html | 1624 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1624 insertions(+) create mode 100644 docs/doxygen/nel/a02303.html (limited to 'docs/doxygen/nel/a02303.html') diff --git a/docs/doxygen/nel/a02303.html b/docs/doxygen/nel/a02303.html new file mode 100644 index 00000000..3f669c3e --- /dev/null +++ b/docs/doxygen/nel/a02303.html @@ -0,0 +1,1624 @@ + + +NeL: NLNET::CBufSock class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLNET::CBufSock Class Reference

#include <buf_sock.h> +

+

Inheritance diagram for NLNET::CBufSock: +

+ +NLNET::CNonBlockingBufSock +NLNET::CServerBufSock + +

Detailed Description

+CBufSock A socket and its sending buffer +

+ +

+Definition at line 52 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.

virtual ~CBufSock ()
 Destructor.


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)
 CBufSock (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.

bool pushBuffer (const NLMISC::CMemStream &buffer)
void setConnectedState (bool connectedstate)
 Sets the "logically connected" state (changed when processing a connection/disconnection callback).

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


Protected Attributes

bool _KnowConnected
NLMISC::CBufFIFO SendFifo
CTcpSock * Sock

Private Attributes

uint64 _AppId
bool _ConnectedState
NLMISC::TTime _LastFlushTime
NLMISC::CObjectVector< uint8 > _ReadyToSendBuffer
TBlockSize _RTSBIndex
sint32 _TriggerSize
NLMISC::TTime _TriggerTime

Friends

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

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLNET::CBufSock::~CBufSock (   )  [virtual]
+
+ + + + + +
+   + + +

+Destructor. +

+ +

+Definition at line 81 of file buf_sock.cpp. +

+References _AppId, _ConnectedState, _KnowConnected, _LastFlushTime, _ReadyToSendBuffer, _RTSBIndex, _TriggerSize, _TriggerTime, AuthorizedCallback, NLMISC::CObjectVector< uint8 >::clear(), nlassert, nlnettrace, and Sock. +

+

00082 {
+00083         nlassert (this != InvalidSockId);       // invalid bufsock
+00084 
+00085         nlnettrace( "CBufSock::~CBufSock" );
+00086         
+00087         delete Sock; // the socket disconnects automatically if needed
+00088         
+00089         // destroy the structur to be sure that other people will not access to this anymore
+00090         AuthorizedCallback = "";
+00091         Sock = NULL;
+00092         _KnowConnected = false;
+00093         _LastFlushTime = 0;
+00094         _TriggerTime = 0;
+00095         _TriggerSize = 0;
+00096         _ReadyToSendBuffer.clear ();
+00097         _RTSBIndex = 0;
+00098         _AppId = 0;
+00099         _ConnectedState = false;
+00100 }
+
+

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

+Constructor. +

+ +

+Definition at line 52 of file buf_sock.cpp. +

+References _LastFlushTime, nlnettrace, and Sock. +

+

00052                                    :
+00053         SendNextValue(0),
+00054         ReceiveNextValue(0),
+00055         Sock( sock ),
+00056         _KnowConnected( false ),
+00057         _LastFlushTime( 0 ),
+00058         _TriggerTime( 20 ),
+00059         _TriggerSize( -1 ),
+00060         _RTSBIndex( 0 ),
+00061         _AppId( 0 ),
+00062         _ConnectedState( false )
+00063 {
+00064         nlnettrace( "CBufSock::CBufSock" ); // don't define a global object
+00065 
+00066         if ( Sock == NULL )
+00067           {
+00068                 Sock = new CTcpSock();
+00069           }
+00070 
+00071 #ifdef NL_DEBUG
+00072         _FlushTrigger = FTManual;
+00073 #endif
+00074         _LastFlushTime = CTime::getLocalTime();
+00075 }
+
+
+

Member Function Documentation

+

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

+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 _KnowConnected, 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]
+
+ + + + + +
+   + + +

+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 asString(), buffer, condition, nlassert, nldebug, NLNET::CBufNetBase::pushMessageIntoReceiveQueue(), and NLNET::TSockId. +

+Referenced by NLNET::CServerBufSock::advertiseConnection(), and 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]
+
+ + + + + +
+   + + +

+Returns the application identifier. +

+ +

+Definition at line 63 of file buf_sock.h. +

+References _AppId, and uint64. +

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

+

00063 { return _AppId; }
+
+

+ + + + +
+ + + + + + + + + +
string NLNET::CBufSock::asString (   )  const
+
+ + + + + +
+   + + +

+Returns a string with the characteristics of the object. +

+ +

+Definition at line 329 of file buf_sock.cpp. +

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

+Referenced by advertiseSystemEvent(), NLNET::CCallbackNetBase::authorizeOnly(), NLNET::CBufServer::dataAvailable(), flush(), NLNET::CCallbackNetBase::processOneMessage(), NLNET::CNonBlockingBufSock::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]
+
+ + + + + +
+   + + +

+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 _ConnectedState, _KnowConnected, addr, NLNET::CTcpSock::connect(), NLNET::CSock::connected(), nlassert, ReceiveNextValue, SendNextValue, NLNET::CTcpSock::setNoDelay(), and 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]
+
+ + + + + +
+   + + +

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

+ +

+Definition at line 237 of file buf_sock.h. +

+References _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]
+
+ + + + + +
+   + + +

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

+ +

+Definition at line 315 of file buf_sock.cpp. +

+References _ConnectedState, _KnowConnected, NLNET::CTcpSock::disconnect(), nlassert, ReceiveNextValue, SendNextValue, and 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 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CBufSock::flush (   )  [protected]
+
+ + + + + +
+   + + +

+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 _ReadyToSendBuffer, _RTSBIndex, 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(), SendFifo, NLMISC::CObjectVector< uint8 >::size(), size, Sock, NLNET::TBlockSize, uint, uint32, and uint8. +

+Referenced by NLNET::CBufServer::disconnect(), NLNET::CBufClient::disconnect(), NLNET::CBufServer::flush(), NLNET::CBufClient::flush(), and 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 }
+
+

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

+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, SendFifo, Sock, uint32, and 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         }
+
+

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

+Sets the application identifier. +

+ +

+Definition at line 60 of file buf_sock.h. +

+References _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]
+
+ + + + + +
+   + + +

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

+ +

+Definition at line 234 of file buf_sock.h. +

+References _ConnectedState. +

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

+

00234 { _ConnectedState = connectedstate; } 
+
+

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

+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 _TriggerSize, sint32, and size. +

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

+

00104 { _TriggerSize = size; }
+
+

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

+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 _LastFlushTime, _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]
+
+ + + + + +
+   + + +

+Returns "CLT " (client). +

+ +

+Reimplemented in NLNET::CServerBufSock. +

+Definition at line 115 of file buf_sock.h. +

+Referenced by asString(). +

+

00115 { return "CLT "; }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CBufSock::update (   )  [protected]
+
+ + + + + +
+   + + +

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

+ +

+Definition at line 247 of file buf_sock.cpp. +

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

+Referenced by 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 in NLNET::CNonBlockingBufSock. +

+Definition at line 78 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CBufServer [friend] +
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLNET::CServerBufSock. +

+Definition at line 79 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CCallbackClient [friend] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 83 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CCallbackNetBase [friend] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 85 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CCallbackServer [friend] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 84 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CClientReceiveTask [friend] +
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLNET::CNonBlockingBufSock. +

+Definition at line 80 of file buf_sock.h.

+

+ + + + +
+ + +
friend class CServerReceiveTask [friend] +
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLNET::CServerBufSock. +

+Definition at line 81 of file buf_sock.h.

+

Field Documentation

+

+ + + + +
+ + +
uint64 NLNET::CBufSock::_AppId [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 262 of file buf_sock.h. +

+Referenced by appId(), setAppId(), and ~CBufSock().

+

+ + + + +
+ + +
bool NLNET::CBufSock::_ConnectedState [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 265 of file buf_sock.h. +

+Referenced by connect(), connectedState(), disconnect(), setConnectedState(), and ~CBufSock().

+

+ + + + +
+ + +
bool NLNET::CBufSock::_KnowConnected [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 246 of file buf_sock.h. +

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

+

+ + + + +
+ + +
NLMISC::TTime NLNET::CBufSock::_LastFlushTime [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 255 of file buf_sock.h. +

+Referenced by CBufSock(), setTimeFlushTrigger(), update(), and ~CBufSock().

+

+ + + + +
+ + +
NLMISC::CObjectVector<uint8> NLNET::CBufSock::_ReadyToSendBuffer [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 259 of file buf_sock.h. +

+Referenced by flush(), and ~CBufSock().

+

+ + + + +
+ + +
TBlockSize NLNET::CBufSock::_RTSBIndex [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 260 of file buf_sock.h. +

+Referenced by flush(), and ~CBufSock().

+

+ + + + +
+ + +
sint32 NLNET::CBufSock::_TriggerSize [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 257 of file buf_sock.h. +

+Referenced by setSizeFlushTrigger(), update(), and ~CBufSock().

+

+ + + + +
+ + +
NLMISC::TTime NLNET::CBufSock::_TriggerTime [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 256 of file buf_sock.h. +

+Referenced by setTimeFlushTrigger(), update(), and ~CBufSock().

+

+ + + + +
+ + +
std::string NLNET::CBufSock::AuthorizedCallback +
+
+ + + + + +
+   + + +

+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 ~CBufSock().

+

+ + + + +
+ + +
uint32 NLNET::CBufSock::ReceiveNextValue +
+
+ + + + + +
+   + + +

+ +

+Definition at line 74 of file buf_sock.h. +

+Referenced by connect(), and disconnect().

+

+ + + + +
+ + +
NLMISC::CBufFIFO NLNET::CBufSock::SendFifo [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 240 of file buf_sock.h. +

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

+

+ + + + +
+ + +
uint32 NLNET::CBufSock::SendNextValue +
+
+ + + + + +
+   + + +

+ +

+Definition at line 74 of file buf_sock.h. +

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

+

+ + + + +
+ + +
CTcpSock* NLNET::CBufSock::Sock [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 243 of file buf_sock.h. +

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

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 13:53:53 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1