//============================================================
void MProperties32::Unpack(TChar32C* pPack){
TString32Refer value(pPack);
TInt count = value.Length();
TInt offset = 0;
while(offset < count){
// name
TFsName32 nameLenLenStr = value.SubStrC(offset, offset + 1);
offset++;
TInt nameLenLen = RNumber<TInt32>::ParseSign<TChar32>(nameLenLenStr);
MO_ASSERT(nameLenLen >0 && nameLenLen <=9);
TFsName32 nameLenStr = value.SubStrC(offset, offset + nameLenLen);
offset += nameLenLen;
TInt nameLen = RNumber<TInt32>::ParseSign<TChar32>(nameLenStr);
_pNames->Push(value.SubStrC(offset, offset + nameLen));
offset+= nameLen;
// value
TFsName32 valueLenLenStr = value.SubStrC(offset, offset + 1);
offset++;
TInt valueLenLen = RNumber<TInt32>::ParseSign<TChar32>(valueLenLenStr);
MO_ASSERT((valueLenLen > 0) && (valueLenLen <= 9));
TFsName32 valueLenStr = value.SubStrC(offset, offset + valueLenLen);
offset += valueLenLen;
TInt valueLen = RNumber<TInt32>::ParseSign<TChar32>(valueLenStr);
_pNames->Push(value.SubStrC(offset, offset + valueLen));
offset+= valueLen;
++_count;
}
}
//============================================================
// <T>从管道内弹出一个完整的数据。</T>
// <P>先读出数据长度(4byte)，再读出数据内容。</P>
//
// @param pData 数据指针
// @param capacity 数据长度
// @return 读出数据的长度，为0表示没有读出有效数据，为-1表示读出缓冲不够
//============================================================
EStreamResult FBufferedQueueBlock::Pop(TAny* pData, TInt capacity, TInt* pLength){
// 检查参数
MO_ASSERT(pData);
MO_ASSERT(capacity > 0);
// 检查容量
TInt position = _position + sizeof(TInt32);
if(position >= _length){
return EStreamResult_ReadEnd;
}
// 检查数据长度
FStreamBlockHead* pHead = (FStreamBlockHead*)(_pMemory + _position);
// 检查长度
if(pHead->length > capacity){
MO_WARN(TC("Current data capacity is not enouth. (data=0x%08X, capacity=%d, length=%d)"), pData, capacity, pHead->length);
return EStreamResult_ReadCapacity;
}
// 检查有效
if(position + pHead->length > _length){
MO_WARN(TC("Current data is invalid. (data=0x%08X, capacity=%d, length=%d)"), pData, capacity, pHead->length);
return EStreamResult_ReadEnd;
}
// 读取数据
MO_LIB_MEMORY_COPY(pData, capacity, pHead->data, pHead->length);
// 设置位置
#ifdef _MO_DEBUG
_count--;
#endif // _DEBUG
_position += sizeof(TInt32) + pHead->length;
*pLength = pHead->length;
return EStreamResult_Success;
}
//============================================================
// <T>将字符串转化为16位字符串</T>
//
// @param pTarget转换后的字符串
// @param size pTarget容量
// @param pValue 被转换字符串
// @return 所需要长度，如果失败返回-1
//============================================================
TInt RString16::ConvertToString16(TChar16* pTarget, TInt size, TChar16C* pValue){
MO_ASSERT(pTarget);
MO_ASSERT(pValue);
TSize length = MO_LIB_STRING_LENGTH16(pValue);
MO_LIB_MEMORY_COPY(pTarget, sizeof(TChar16) * length, pValue, sizeof(TChar16) * length);
return length;
}
//============================================================
TBool FNetMessageConsole::ConnectionUnregister(FNetMessageConnection* pConnection){
MO_ASSERT(pConnection);
MO_ASSERT(_pConnections->Contains(pConnection));
_pConnections->Remove(pConnection);
_pReceiveThread->Unregister(pConnection);
return ETrue;
}
//============================================================
// <T>将字符串转化为8位字符串</T>
//
// @param pTarget转换后的字符串
// @param size pTarget容量
// @param pValue 被转换字符串
// @return 所需要长度，如果失败返回-1
//============================================================
TInt RString16::ConvertToString8(TChar8* pTarget, TInt size, TChar16C* pValue){
MO_ASSERT(pTarget);
MO_ASSERT(pValue);
TSize length = MO_LIB_STRING_LENGTH16(pValue);
#ifdef _MO_WINDOWS
TInt result = WideCharToMultiByte(CP_ACP, 0, pValue, length, pTarget, size, NULL, NULL);
#endif // _MO_WINDOWS
#ifdef _MO_LINUX
iconv_t code = iconv_open("GBK", "UTF-8");
if(NULL == code){
MO_STATIC_FATAL("Iconv open failure.");
}
TChar8* pInput = (TChar8*)pValue;
TSize inputLength = length;
TSize outputLength = size;
TInt result = iconv(code, &pInput, &inputLength, &pTarget, &outputLength);
if(-1 == result){
MO_STATIC_FATAL("Iconv convert failure.");
return -1;
}
iconv_close(code);
pTarget[outputLength] = 0;
#endif // _MO_LINUX
#ifdef _MO_ANDROID
TInt result = length;
// g_lpdlIcuuc = dlopen("/system/lib/libicuuc.so", RTLD_LAZY);
#endif // _MO_ANDROID
return result;
}
//============================================================
// <T>获得运行信息。</T>
//
// @param pDump 运行内容
// @param capacity 容量
// @return 运行信息
//============================================================
TCharC* FClassFactory::Dump(TChar* pDump, TInt capacity){
MO_ASSERT(pDump);
MO_ASSERT(capacity > 0);
TStringRefer dump(pDump, capacity);
dump.AppendFormat(TC("count=%d"), _pClasses->Count());
return pDump;
}
//============================================================
// <T>收集一块指定大小的内存。</T>
//
// @param size 内存大小
// @return 内存指针
//============================================================
TAny* FMemoryAllocator::Alloc(TInt size){
MO_ASSERT(size > 0);
SMemoryEntry* pEntry = EntryAlloc();
MO_ASSERT(pEntry);
TByte* pMemory = (TByte*)MO_ALIGNED_ALLOC(size, sizeof(TInt));
pEntry->Link(pMemory, size);
return pEntry->pMemory;
}
//============================================================
// <T>收集一块指定大小的内存。</T>
//
// @param pOwnerName 拥有者名称
// @param pTypeName 类型名称
// @param size 内存大小
// @param pFileName 文件名称
// @param fileLine 文件行数
// @return 内存指针
//============================================================
TAny* FMemoryAllocator::Alloc(TCharC* pOwnerName, TCharC* pTypeName, TInt size, TChar8C* pFileName, TInt lineNumber){
MO_ASSERT(size > 0);
SMemoryEntry* pEntry = EntryAlloc();
MO_ASSERT(pEntry);
TByte* pMemory = (TByte*)MO_ALIGNED_ALLOC(size, sizeof(TInt));
pEntry->SetTypeName(pTypeName);
pEntry->SetFileInfo(pFileName, lineNumber);
pEntry->Link(pMemory, size);
return pEntry->pMemory;
}
//============================================================
// <T>将一个完整信息写入管道。</T>
// <P>先写入数据长度(4byte)，再写入数据内容。
// 数据内容可能被分成两端放入管道的尾部和首部。</P>
// 每次结尾位置的偏移只能为4byte的倍数(sizeof(TUint32))。
// </P>
//
// @param pData 数据指针
// @param capacity 数据长度
// @return 压入是否成功
//============================================================
TBool FQueue::Push(TAnyC* pData, TInt size){
// 检查参数
MO_ASSERT(pData);
if(0 == size){
return ETrue;
}
// 获取变量
SPipeAtom atom = Atom();
// 判断是否可以写入
if((atom.capacity - atom.length) < (size + MoPipeReserveLength)){
return EFalse;
}
// 写入数据
TInt position = 0;
if(atom.first <= atom.last){
// 处理写入数据 [---F===L----]
TInt remain = atom.capacity - atom.last;
MO_ASSERT(remain >= (TInt)sizeof(TUint32));
*(TUint32*)(atom.memoryPtr + atom.last) = size;
remain -= sizeof(TUint32);
TByte* pLast = atom.memoryPtr + atom.last + sizeof(TUint32);
// 写入数据
if(size < remain){
memcpy(pLast, pData, size);
position = atom.last + sizeof(TUint32) + size;
}else if(size == remain){
memcpy(pLast, pData, size);
position = 0;
}else{
memcpy(pLast, pData, remain);
memcpy(atom.memoryPtr, (TByte*)pData + remain, size - remain);
position = size - remain;
}
}else{
// 处理写入数据 [===L---F====]
TByte* pWrite = atom.memoryPtr + atom.last;
*(TUint32*)pWrite = size;
pWrite += sizeof(TUint32);
// 写入数据
memcpy(pWrite, pData, size);
position = atom.last + sizeof(TUint32) + size;
}
// 设置结尾位置
TInt mod = position % sizeof(TUint32);
if(0 != mod){
position += sizeof(TUint32) - mod;
}
if(position == atom.capacity){
position = 0;
}
atom.SetLast(position);
return ETrue;
}
//============================================================
// <T>从管道内弹出一个完整的消息。</T>
// <P>先读出数据长度(4byte)，再读出数据内容。
// 数据内容可能被分成两端放入管道的尾部和首部。</P>
// 每次开始位置的偏移只能为4byte的倍数(sizeof(TUint32))。
// </P>
//
// @param pData 数据指针
// @param capacity 数据长度
// @return 读出数据的长度，为0表示没有读出有效数据
//============================================================
TInt FQueue::Pop(TAny* pData, TInt capacity){
// 检查参数
MO_ASSERT(pData);
MO_ASSERT(capacity > 0);
// 获取变量
SPipeAtom atom = Atom();
// 判断是否可以读出
if(atom.length <= (TInt)sizeof(TUint32)){
return 0;
}
TByte* pRead = atom.memoryPtr + atom.first;
TInt size = *(TUint32*)pRead;
MO_ASSERT(size > 0);
MO_ASSERT(size <= atom.capacity);
MO_ASSERT(size <= atom.length);
pRead += sizeof(TUint32);
// 读取数据
TInt position = 0;
if(atom.first < atom.last){
// 处理读取数据 [---F===L----]
memcpy(pData, pRead, size);
position = atom.first + sizeof(TUint32) + size;
}else{
// 处理读取数据 [===L---F====]
TInt remain = atom.capacity - atom.first - sizeof(TUint32);
if(size < remain){
memcpy(pData, pRead, size);
position = atom.first + sizeof(TUint32) + size;
}else if(size == remain){
memcpy(pData, pRead, size);
position = 0;
}else{
memcpy(pData, pRead, remain);
memcpy((TByte*)pData + remain, atom.memoryPtr, size - remain);
position = size - remain;
}
}
// 设置开始位置
TInt mod = position % sizeof(TUint32);
if(0 != mod){
position += sizeof(TUint32) - mod;
}
if(position == atom.capacity){
position = 0;
}
atom.SetFirst(position);
return size;
}
//============================================================
// <T>反序列化数据区到内部数据。</T>
//
// @param pMemory 数据指针
// @param size 数据长度
// @param [out] length 读取长度
//============================================================
TBool TNetMessageBuffer::UnserializeMask(TAnyC* pMemory, TInt size, TInt* length){
MO_ASSERT(pMemory);
TByteC* pPtr = (TByteC*)pMemory;
// 反序列化头数据
TInt offset = 0;
offset += _netHead.Unserialize(pPtr);
TNetLength netLength = _netHead.Length();
TNetHash netHash = _netHead.Hash();
offset += _messageHead.Unserialize(pPtr + offset);
TNetSerial messageSerial = _messageHead.Serial();
TNetTick messageTick = _messageHead.Tick();
// 获取数据
TByteC* pData = pPtr + offset;
TInt dataLength = netLength - offset;
// 还原数据
TByte buffer[MO_NETMESSAGE_MAXLENGTH];
MaskData(buffer, MO_NETMESSAGE_MAXLENGTH, pData, dataLength, netHash);
//TChar dump[MO_FS_DUMP_LENGTH];
//MO_ERROR("Receive message data failure.\n%s",
// RByte::Dump(buffer, dataLength, dump, MO_FS_DUMP_LENGTH));
// 检查哈希
TNetHash hash = CalculateHash(messageSerial, messageTick, buffer, dataLength);
if(netHash != hash){
MO_WARN(TC("Unserialize message invalid hash. (head_hash=0x%08X, data_hash=0x%08X)"), netHash, hash);
return EFalse;
}
// 设置数据
if(dataLength > 0){
memcpy(_buffer, buffer, dataLength);
}
_dataLength = dataLength;
*length = netLength;
return ETrue;
}
void serialize(AR& ar, cv::Matx<T, rows, cols>& mat){
cereal::size_type size = rows * cols;;
ar(cereal::make_size_tag(size));
MO_ASSERT(size == rows * cols);
for(int i = 0; i < rows * cols; ++i)
ar(mat.val[i]);
}
//============================================================
// <T>配置处理。</T>
//
// @return 处理结果
//============================================================
TResult FDisplayLayer::Setup(){
MO_ASSERT(!_pParticleController);
_pParticleController = MO_CREATE(FParticleController);
_visualRegion = FVisualRegion::InstanceCreate();
RVisualManager::Instance().RegionRegister(_visualRegion);
return ESuccess;
}
//============================================================
// <T>压缩内部数据到数据区。</T>
//
// @param pMemory 数据指针
// @param size 数据长度
// @param [out] length 读取长度
//============================================================
TBool TNetMessageBuffer::Compress(TAny* pMemory, TInt size, TInt* pLength){
MO_ASSERT(pMemory);
TByte* pPtr = (TByte*)pMemory;
// 获得头长度
TInt netCapacity = _netHead.Capacity();
TInt messageCapacity = _messageHead.Capacity();
TNetSerial messageSerial = _messageHead.Serial();
TNetTick messageTick = _messageHead.Tick();
TInt headCapacity = netCapacity + messageCapacity;
TSize capacity = headCapacity + _dataLength;
// 设置头信息
TNetHash hash = CalculateHash(messageSerial, messageTick, _pData, _dataLength);
_netHead.SetLength((TNetLength)capacity);
_netHead.SetHash(hash);
// 序列头信息
_netHead.Serialize(pPtr);
_messageHead.Serialize(pPtr + headCapacity);
// 压缩数据
TInt length = 0;
if(!RCompress::CompressRLE(pPtr + headCapacity, size, _pData, _dataLength, &length)){
return EFalse;
}
// 设置序列化后大小
*pLength = headCapacity + length;
return ETrue;
}
//============================================================
// <T>释放内存。</T>
//
// @param pMemory 内存指针
//============================================================
void FMemoryAllocator::Free(TAny* pMemory){
// 获得当前使用的实例
MO_ASSERT(pMemory);
TInt* pAlloc = ((TInt*)pMemory) - 1;
SMemoryEntry* pEntry = (SMemoryEntry*)pAlloc[0];
MO_ASSERT(pEntry);
// 检查内存转换正确性
MO_ASSERT(pEntry->pAllocator == this);
MO_ASSERT(pEntry->pMemory == pMemory);
// 释放内存
MO_ALIGNED_FREE(pEntry->pAlloc);
// 记录释放操作
pEntry->Free();
// 压入未使用的队列
//MLinkedEntryC<SMemoryEntry*>::EntryFree(pEntry);
}
//============================================================
// <T>调整内存大小。</T>
//
// @param size 大小
// @param copy 复制
// @param extends 扩展
//============================================================
void TStringBuffer8::InnerResize(TInt size, TBool copy, TBool extends, TBool force){
if(size > _capacity){
// 当内存不足时，重新计算内存容量
TInt capacity = size;
if(extends){
capacity = RTypes<TChar8>::CalculateTypeCapacity(_capacity, size);
}
// 如果收集不成功，则不进行复制数据处理
TChar8* pAlloc = MO_TYPES_ALLOC(TChar8, capacity);
MO_ASSERT(pAlloc);
// 如果存在以前内存
if(NULL != _pMemory){
// 如果是缩小内存，则检查长度
if(_length > capacity){
_length = capacity;
}
// 复制有效数据
if(copy && (_length > 0)){
MO_LIB_TYPES_COPY(TChar8, pAlloc, capacity, _pMemory, _length);
}
// 释放以前内存
MO_FREE(_pMemory);
}
// 设置新的内存
_pMemory = pAlloc;
_pMemory[_length] = 0;
_capacity = capacity;
}
}
//============================================================
void TNetMessageBuffer::AssignData(TByteC* pData, TInt length){
MO_ASSERT(pData);
if(length > 0){
memcpy(_buffer, pData, length);
}
_dataLength = length;
}
//============================================================
// <T>将一个数据写入管道。</T>
//
// @param pData 数据指针
// @param length 数据长度
// @return 压入是否成功
//============================================================
EStreamResult FBufferedQueueBlock::Push(TAnyC* pData, TInt length){
// 检查参数
MO_ASSERT(pData);
// 检查长度
if(0 == length){
MO_WARN(TC("Write empty data. (data=0x%08X, length=%d)"), pData, length);
return EStreamResult_WriteEmpty;
}
// 判断管道是否可以写入
TInt free = _length - _position;
TInt dataSize = sizeof(TInt32) + length;
if(dataSize > free){
MO_WARN(TC("Current queue is full. (data=0x%08X, capacity=%d, position=%d, free=%d, length=%d)"), pData, _capacity, _position, free, length);
return EStreamResult_WriteFull;
}
// 写入数据
FStreamBlockHead* pHead = (FStreamBlockHead*)(_pMemory + _position);
pHead->length = length;
MO_LIB_MEMORY_COPY(pHead->data, free, pData, length);
// 设置位置
_position += sizeof(TInt32) + length;
#ifdef _MO_DEBUG
_count++;
if(_count > _countMax){
_countMax = _count;
}
#endif // _DEBUG
return EStreamResult_Success;
}
//============================================================
// <T>压入一个消息。</T>
//
// @param pMessage 消息对象
// @return 处理结果
//============================================================
TBool FNetBufferedQueue::PushTransfer(TNetTransfer* pTransfer){
MO_ASSERT(pTransfer);
// 序列化路由数据
TInt length = 0;
TByte buffer[MO_NETMESSAGE_MAXLENGTH];
if(!pTransfer->Serialize(buffer, MO_NETMESSAGE_MAXLENGTH, &length)){
MO_FATAL("Transfer serialize failure. (message_code=%d)", pTransfer->MessageHead().Code());
return EFalse;
}
if(length <= 0){
MO_FATAL("Transfer serialize failure. (message_code=%d, length=%d)", pTransfer->MessageHead().Code(), length);
return EFalse;
}
// 消息检查
TInt bufferLength = *(TInt32*)(TAny*)buffer;
if(bufferLength > MO_NETMESSAGE_MAXLENGTH){
MO_FATAL("Write message length is error. (memory=0x%08X, block_length=%d)", buffer, bufferLength);
}
if(length > MO_NETMESSAGE_MAXLENGTH){
MO_FATAL("Write data length is error. (memory=0x%08X, data_length=%d)", buffer, length);
}
if(bufferLength != length){
MO_FATAL("Write data length is not equals. (memory=0x%08X, block_length=%d, data_length=%d)", buffer, bufferLength, length);
}
// 将数据放入管道
return FBufferedQueue::Push(buffer, length);
}
//============================================================
// <T>序列化路由数据到数据区。</T>
//
// @param pMemory 数据指针
// @param size 数据大小
// @param length 处理大小
//============================================================
TBool TNetRouter::SerializeRouter(TAny* pMemory, TInt size, TInt* length){
MO_ASSERT(pMemory);
TByte* pPtr = (TByte*)pMemory;
// 获取头大小
TInt netCapacity = _netHead.Capacity();
TInt messageCapacity = _messageHead.Capacity();
TNetSerial messageSerial = _messageHead.Serial();
TNetTick messageTick = _messageHead.Tick();
TInt routerCapacity = _routerHead.Capacity();
TInt headCapacity = netCapacity + messageCapacity + routerCapacity;
TInt capacity = headCapacity + _dataLength;
TByte* pData = pPtr + headCapacity;
// 设置头信息
TNetHash hash = CalculateHash(messageSerial, messageTick, _pData, _dataLength);
_netHead.SetLength((TNetLength)capacity);
_netHead.SetProtocol(ENetProtocol_Router);
_netHead.SetHash(hash);
// 序列化头数据
TInt offset = 0;
offset += _netHead.Serialize(pPtr);
offset += _messageHead.Serialize(pPtr + offset);
offset += _routerHead.Serialize(pPtr + offset);
if(_dataLength > 0){
memcpy(pData, _pData, _dataLength);
}
// 设置序列化后大小
*length = capacity;
return ETrue;
}
//============================================================
// <T>反序列化数据区到内部数据。</T>
//
// @param pMemory 数据指针
// @param size 数据长度
// @param [out] length 读取长度
//============================================================
TBool TNetMessageBuffer::Unserialize(TAnyC* pMemory, TInt size, TInt* length){
MO_ASSERT(pMemory);
TByteC* pPtr = (TByteC*)pMemory;
// 反序列化头数据
TInt offset = 0;
offset += _netHead.Unserialize(pPtr);
offset += _messageHead.Unserialize(pPtr + offset);
TNetSerial messageSerial = _messageHead.Serial();
TNetTick messageTick = _messageHead.Tick();
// 获取数据
TNetLength netLength = _netHead.Length();
TByteC* pData = pPtr + offset;
TInt dataLength = netLength - offset;
// 检查哈希
TNetHash hash = CalculateHash(messageSerial, messageTick, pData, dataLength);
if(_netHead.Hash() != hash){
MO_WARN(TC("Unserialize message invalid hash. (head_hash=0x%08X, data_hash=0x%08X)"),
_netHead.Hash(), hash);
return EFalse;
}
// 设置数据
if(dataLength > 0){
memcpy(_buffer, pData, dataLength);
}
_dataLength = dataLength;
*length = netLength;
return ETrue;
}
//============================================================
// <T>序列化内部数据到数据区。</T>
//
// @param pMessage 消息对象
//============================================================
TBool TNetMessageBuffer::Serialize(TAny* pMemory, TInt size, TInt* length){
MO_ASSERT(pMemory);
TByte* pPtr = (TByte*)pMemory;
// 获得头长度
TInt netCapacity = _netHead.Capacity();
TInt messageCapacity = _messageHead.Capacity();
TNetSerial messageSerial = _messageHead.Serial();
TNetTick messageTick = _messageHead.Tick();
TInt headCapacity = netCapacity + messageCapacity;
TSize capacity = headCapacity + _dataLength;
// 设置头信息
TNetHash hash = CalculateHash(messageSerial, messageTick, _pData, _dataLength);
_netHead.SetLength((TNetLength)capacity);
_netHead.SetHash(hash);
// 序列头信息
_netHead.Serialize(pPtr);
_messageHead.Serialize(pPtr + headCapacity);
// 序列化数据
if(_dataLength > 0){
memcpy(pPtr + headCapacity, _pData, _dataLength);
}
// 设置序列化后大小
*length = capacity;
return ETrue;
}
//============================================================
void MProperties32::Set(TChar32C* pName, TChar32C* pValue){
TInt index = _pNames->IndexOf(pName);
MO_ASSERT(ENotFound != index);
while(ENotFound != index){
_pValues->Set(index, pValue);
index = _pNames->IndexOf(pName);
}
}
//============================================================
// <T>弹出陷阱对象。</T>
//============================================================
void FThreadTrap::Pop(){
MO_ASSERT(_pUsed);
// 获得当前使用的实例
FTrap* pTrap = _pUsed;
_pUsed = pTrap->Parent();
// 压入未使用的队列
pTrap->SetParent(_pUnused);
_pUnused = pTrap;
}
//============================================================
// <T>收集一个实例。</T>
//
// @param pName 名称
// @return 实例
//============================================================
FInstance* FClassFactory::Alloc(TCharC* pName){
MO_ASSERT(pName);
FInstance* pInstance = NULL;
FClass* pClass = _pClasses->Find(pName);
if(pClass != NULL){
pInstance = pClass->InstanceAlloc();
}
return pInstance;
}
//============================================================
// <T>设置处理。</T>
//
// @param capacity 容量
// @param pAllocator 收集器
//============================================================
void FNetBufferedQueueConnection::Setup(TInt capacity, FBufferedQueueBlockAllocator* pAllocator){
MO_ASSERT(capacity > 0);
// 设置输入流
_pInputQueue->SetLockCd(EStreamLock_Lock);
_pInputQueue->Pool()->SetCapacity(capacity);
_pInputQueue->SetAllocator(pAllocator);
// 设置输出流
_pOutputQueue->SetLockCd(EStreamLock_Lock);
_pOutputQueue->Pool()->SetCapacity(capacity);
_pOutputQueue->SetAllocator(pAllocator);
}
//============================================================
TString32 MProperties32::Remove(TChar32C* pName){
TString32 value;
TInt index = _pNames->IndexOf(pName);
MO_ASSERT(ENotFound != index);
value.Append(_pNames->Get(index));
value.Append(_pValues->Get(index));
_pNames->Delete(index);
_pValues->Delete(index);
--_count;
return value;
}
//============================================================
// <T>压入一个消息。</T>
//
// @param pMessage 消息对象
// @return 处理结果
//============================================================
TBool FNetBufferedQueue::PushMessage(TNetMessage* pMessage){
MO_ASSERT(pMessage);
// 序列化路由数据
TInt length;
TByte buffer[MO_NETMESSAGE_MAXLENGTH];
if(!pMessage->Serialize(buffer, MO_NETMESSAGE_MAXLENGTH, &length)){
MO_FATAL("Message serialize failure.");
}
// 将数据放入管道
return FBufferedQueue::Push(buffer, length);
}
//============================================================
// <T>压入一个路由。</T>
//
// @param pRouter 路由对象
// @return 处理结果
//============================================================
TBool FNetBufferedQueue::PushRouter(TNetRouter* pRouter){
MO_ASSERT(pRouter);
// 序列化路由数据
TInt length;
TByte buffer[MO_NETMESSAGE_MAXLENGTH];
if(!pRouter->Serialize(buffer, MO_NETMESSAGE_MAXLENGTH, &length)){
MO_FATAL("Router serialize failure.");
}
// 将数据放入管道
return FBufferedQueue::Push(buffer, length);
}
//============================================================
// <T>解析16进制字符串。</T>
//
// @param pSource 来源
// @param length 长度
// @return 内容
//============================================================
TUint32 RUint32::ParseHex(TCharC* pSource, TInt length){
MO_ASSERT(pSource);
TUint32 v0 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[0]]) << 28;
TUint32 v1 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[1]]) << 24;
TUint32 v2 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[2]]) << 20;
TUint32 v3 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[3]]) << 16;
TUint32 v4 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[4]]) << 12;
TUint32 v5 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[5]]) << 8;
TUint32 v6 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[6]]) << 4;
TUint32 v7 = ((TUint32)RByte::HEX_BYTES[(TInt)pSource[7]]) ;
return v0 | v1 | v2 | v3 | v4 | v5 | v6 | v7;
}
