#pragma once
|
|
#include "akNetworkLinker.h"
|
#include <WinSock2.h>
|
#include <queue>
|
|
class _packetData
|
{
|
public:
|
_packetData()
|
{
|
m_nLen = 0;
|
m_pData = NULL;
|
};
|
_packetData(const _packetData& rhs)
|
{
|
m_nLen = 0;
|
m_pData = NULL;
|
|
if(rhs.m_nLen > 0)
|
{
|
m_pData = new char[rhs.m_nLen+1];
|
memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nLen));
|
m_pData[rhs.m_nLen] = 0;
|
m_nLen = rhs.m_nLen;
|
}
|
}
|
~_packetData()
|
{
|
clear();
|
};
|
_packetData& operator=(const _packetData& rhs)
|
{
|
clear();
|
if(rhs.m_nLen > 0)
|
{
|
m_pData = new char[rhs.m_nLen+1];
|
memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nLen));
|
m_pData[rhs.m_nLen] = 0;
|
m_nLen = rhs.m_nLen;
|
}
|
return *this;
|
};
|
void clear()
|
{
|
if(m_nLen > 0)
|
{
|
delete [] m_pData;
|
m_pData = NULL;
|
m_nLen = 0;
|
}
|
}
|
void setData(char* pData, long nLen)
|
{
|
clear();
|
if(nLen <= 0 || pData == NULL)
|
{
|
return;
|
}
|
|
m_pData = new char[nLen+1];
|
memcpy(m_pData, pData, sizeof(char)*nLen);
|
m_pData[nLen] = 0;
|
m_nLen = nLen;
|
}
|
public:
|
char* m_pData;
|
long m_nLen;
|
};
|
|
class CPacketStorage
|
{
|
public:
|
CPacketStorage(void);
|
virtual ~CPacketStorage(void);
|
|
public:
|
void clear(){while(!m_quePacketData.empty());m_quePacketData.pop();};
|
|
void EnterSection(){EnterCriticalSection(&m_csSection);};
|
void LeaveSection(){LeaveCriticalSection(&m_csSection);};
|
|
void push(_packetData& data){m_quePacketData.push(data);};
|
|
_packetData* front(){return &m_quePacketData.front();};
|
void pop(){m_quePacketData.pop();};
|
|
size_t size(){return m_quePacketData.size();};
|
bool empty(){return m_quePacketData.empty();};
|
protected:
|
CRITICAL_SECTION m_csSection;
|
std::queue<_packetData> m_quePacketData;
|
};
|
|
class _akPacketPoolData
|
{
|
public:
|
_akPacketPoolData()
|
{
|
m_nMemorySize = m_nDataSize = 0;
|
m_pData = NULL;
|
};
|
_akPacketPoolData(const _akPacketPoolData& rhs)
|
{
|
alloc(rhs.m_nMemorySize);
|
if(rhs.m_nMemorySize > 0)
|
{
|
memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nMemorySize));
|
m_nDataSize = rhs.m_nDataSize;
|
m_nMemorySize = rhs.m_nMemorySize;
|
}
|
}
|
~_akPacketPoolData()
|
{
|
clear();
|
};
|
_akPacketPoolData& operator=(const _akPacketPoolData& rhs)
|
{
|
alloc(rhs.m_nMemorySize);
|
if(rhs.m_nMemorySize > 0)
|
{
|
memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nMemorySize));
|
m_nDataSize = rhs.m_nDataSize;
|
m_nMemorySize = rhs.m_nMemorySize;
|
}
|
return *this;
|
};
|
void clear()
|
{
|
if(m_nMemorySize > 0)
|
{
|
delete [] m_pData;
|
m_pData = NULL;
|
m_nMemorySize = m_nDataSize = 0;
|
}
|
}
|
void alloc(long nSize)
|
{
|
if(nSize > m_nMemorySize)
|
{
|
delete [] m_pData, m_pData = NULL;
|
m_nMemorySize = (nSize/1024+2)*1024;
|
m_pData = new char[m_nMemorySize];
|
}
|
}
|
void setData(char* pData, long nSize)
|
{
|
alloc(nSize);
|
|
memcpy(m_pData, pData, sizeof(char)*nSize);
|
m_pData[nSize] = 0;
|
m_nDataSize = nSize;
|
}
|
public:
|
char* m_pData;
|
long m_nDataSize;
|
long m_nMemorySize;
|
};
|
|
class AKNETWORK_DLLSPEC CakPacketPool
|
{
|
public:
|
CakPacketPool(void);
|
virtual ~CakPacketPool(void);
|
|
public:
|
void clear();
|
|
void setPacketPoolAlloc(int nNum)
|
{
|
setPacketPoolClear();
|
|
m_pPacketPoolBuf = new _akPacketPoolData[nNum];
|
m_nPacketPoolBufNum = nNum;
|
m_nPacketPoolIndex = 0;
|
}
|
void setPacketPoolClear()
|
{
|
if(m_nPacketPoolBufNum)
|
{
|
delete [] m_pPacketPoolBuf;
|
m_nPacketPoolBufNum = 0;
|
m_nPacketPoolIndex = 0;
|
}
|
}
|
int getPacketPoolSize(){return m_nPacketPoolBufNum;};
|
|
_akPacketPoolData* getPacketPool(){return &m_pPacketPoolBuf[m_nPacketPoolIndex];};
|
int getPacketPoolNum(){return m_quePacketPoolOrder.size();};
|
|
void EnterSection(){EnterCriticalSection(&m_csSection);};
|
void LeaveSection(){LeaveCriticalSection(&m_csSection);};
|
|
void push(_akPacketPoolData* pData)
|
{
|
m_quePacketPoolOrder.push(pData);
|
m_nPacketPoolIndex = (m_nPacketPoolIndex+1)%m_nPacketPoolBufNum;
|
};
|
|
_akPacketPoolData* front(){return m_quePacketPoolOrder.front();};
|
void pop(){m_quePacketPoolOrder.pop();};
|
|
size_t size(){return m_quePacketPoolOrder.size();};
|
bool empty(){return m_quePacketPoolOrder.empty();};
|
|
BOOL checkPoolSpare(int nWaitTime = -1)
|
{
|
if(m_quePacketPoolOrder.size() < m_nPacketPoolBufNum)
|
return TRUE;
|
|
DWORD nTimeSt = GetTickCount();
|
while(nTimeSt-GetTickCount() < nWaitTime)
|
{
|
if(m_quePacketPoolOrder.size() < m_nPacketPoolBufNum)
|
return TRUE;
|
|
Sleep(1);
|
}
|
return FALSE;
|
};
|
protected:
|
CRITICAL_SECTION m_csSection;
|
std::queue<_akPacketPoolData*> m_quePacketPoolOrder;
|
|
_akPacketPoolData* m_pPacketPoolBuf;
|
int m_nPacketPoolBufNum;
|
int m_nPacketPoolIndex;
|
};
|
