void CPackager::AddData( BYTE cID, const char * const pData, size_t dataLength, unsigned long lnUserData /* = 0 */ )
{
CCriticalSection::Owner lock( m_csSend );
BUFFER_MAP::iterator it;
if ( m_theSend.end() != ( it = m_theSend.find( cID ) ) )
{
CBuffer *pBuffer = m_theSend[cID];
ASSERT( pBuffer );
pBuffer->SetUserData( lnUserData );
pBuffer->AddData( pData, dataLength );
}
else
{
CBuffer *pBuffer = m_theAllocator.Allocate();
ASSERT( pBuffer );
pBuffer->SetUserData( lnUserData );
pBuffer->AddData( pData, dataLength );
m_theSend[cID] = pBuffer;
}
}
CBuffer *CPackager::PackUp( const void *pData, size_t dataLength )
{
CCriticalSection::Owner lock( m_csRecv );
if ( NULL == pData || dataLength < 3 /* cID + cPackFlag + ... */ )
{
return NULL;
}
BYTE cID = CPackager::Peek( pData );
BUFFER_MAP::iterator it;
if ( m_theRecv.end() == ( it = m_theRecv.find( cID ) ) )
{
CBuffer *pPack = m_theAllocator.Allocate();
m_theRecv[cID] = pPack;
}
CBuffer *pBuffer = m_theRecv[cID];
ASSERT( pBuffer );
BYTE cFlag = CPackager::Peek( pData, 1 );
const size_t nDataBegin = 1 + 1 + sizeof( unsigned long );
if ( _Header( cFlag ) )
{
pBuffer->Empty();
pBuffer->AddData( ( ( const char * )pData + nDataBegin ), dataLength - nDataBegin );
}
if ( _Middle( cFlag ) )
{
pBuffer->AddData( ( ( const char * )pData + nDataBegin ), dataLength - nDataBegin );
}
if ( _Tail( cFlag ) )
{
unsigned long lnUserData = *( const unsigned long * )( ( const char * )pData + 2 );
pBuffer->SetUserData( lnUserData );
pBuffer->AddRef();
return pBuffer;
}
if ( _Error( cFlag ) )
{
ASSERT( NULL && "CPackager::PackUp - Invalid package!" );
}
return NULL;
}
CBuffer *CPackager::GetNextPack( BYTE cID )
{
CCriticalSection::Owner lock( m_csSend );
BUFFER_MAP::iterator it;
if ( m_theSend.end() != ( it = m_theSend.find( cID ) ) )
{
CBuffer *pBuffer = m_theSend[cID];
CBuffer *pPack = pBuffer->GetNextPack();
if ( NULL == pPack )
{
return NULL;
}
if ( 0 == pPack->GetUsed() )
{
pPack->Release();
return NULL;
}
CBuffer *pNewBufer = m_theAllocator.Allocate();
pNewBufer->AddData( cID );
BYTE cFlag = enumPackMiddle;
if ( !pBuffer->HaveNextPack() )
{
cFlag |= enumPackTail;
}
pNewBufer->AddData( cFlag );
/*
* Add a user data into this buffer
*/
unsigned long lnUserData = pBuffer->GetUserData();
pNewBufer->AddData( ( const char * )( &lnUserData ), sizeof( unsigned long ) );
/*
* Add some data into this buffer
*/
pNewBufer->AddData( pPack->GetBuffer(), pPack->GetUsed() );
pPack->Release();
return pNewBufer;
}
return NULL;
}
bool CSmartClient::Send( const void * const pData, const size_t &datalength )
{
if (IsNormal())
{
if (m_pClient)
{
/*
* Send the histroy information to server
*/
{
CCriticalSection::Owner locker( m_csHistroyList );
stdList::iterator it;
for ( it = m_theHistroyList.begin();
it != m_theHistroyList.end();
it ++ )
{
CBuffer *pBuffer = *it;
if ( pBuffer )
{
m_pClient->SendPackToServer(
( const void * )( pBuffer->GetBuffer() ),
pBuffer->GetUsed() );
SAFE_RELEASE( pBuffer );
}
}
m_theHistroyList.clear();
}
if (pData && datalength)
m_pClient->SendPackToServer( pData, datalength );
return true;
}
}
else if (pData && datalength > 0)
{
/* Store data into buffer */
CCriticalSection::Owner locker( m_csHistroyList );
CBuffer *pBuffer = m_theAllocator.Allocate();
ASSERT( pBuffer );
pBuffer->AddData((BYTE*) pData, datalength );
m_theHistroyList.push_back( pBuffer );
}
return false;
}
CBuffer *CBuffer::SplitBuffer( size_t bytesToRemove )
{
CBuffer *pNewBuffer = m_allocator.Allocate();
pNewBuffer->AddData( m_buffer_ptr, bytesToRemove );
m_used -= bytesToRemove;
memmove( m_buffer_ptr, m_buffer_ptr + bytesToRemove, m_used );
return pNewBuffer;
}
bool CClientNode::CDataQueue::AddData( const BYTE *pData, size_t datalength )
{
CBuffer *pBuffer = m_theDQAllocator.Allocate();
pBuffer->AddData( pData, datalength );
{
CCriticalSection::Owner lock( m_csQueue );
m_theData.push_back( pBuffer );
}
return true;
}
CBuffer *CBuffer::GetNextPack()
{
if ( m_offsetNextPack < m_used )
{
CBuffer *pNewBuffer = m_allocator.Allocate();
size_t canused = ( m_offsetNextPack + m_packLength > m_used ) ? ( m_used - m_offsetNextPack ) : m_packLength;
pNewBuffer->AddData( m_buffer_ptr + m_offsetNextPack, canused );
m_offsetNextPack += canused;
return pNewBuffer;
}
return NULL;
}
CBuffer *CBuffer::GetHeadPack( size_t packLength )
{
if ( 0 == m_used || 0 == packLength )
{
return NULL;
}
m_packLength = packLength;
CBuffer *pNewBuffer = m_allocator.Allocate();
size_t canused = ( m_packLength > m_used ) ? m_used : m_packLength;
pNewBuffer->AddData( m_buffer_ptr, canused );
m_offsetNextPack = canused;
return pNewBuffer;
}
