Restructure repository to include all source folders
Move git root from Client/ to src/ to track all source code: - Client: Game client source (moved to Client/Client/) - Server: Game server source - GameTools: Development tools - CryptoSource: Encryption utilities - database: Database scripts - Script: Game scripts - rylCoder_16.02.2008_src: Legacy coder tools - GMFont, Game: Additional resources 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
51
Server/RylServerProject/BaseLibrary/Stream/Buffer/Buffer.cpp
Normal file
51
Server/RylServerProject/BaseLibrary/Stream/Buffer/Buffer.cpp
Normal file
@@ -0,0 +1,51 @@
|
||||
#include "stdafx.h"
|
||||
#include "Buffer.h"
|
||||
#include "BufferFactory.h"
|
||||
|
||||
CBuffer::CBuffer(CBufferFactory& bufferfactory)
|
||||
: internal_buffer_(0), rd_ptr_(0), wr_ptr_(0), buffer_size_(0),
|
||||
bufferfactory_(bufferfactory), next_(0), prev_(0)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
CBuffer::~CBuffer()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
void CBuffer::init(char* internal_buffer, unsigned long buffer_size)
|
||||
{
|
||||
rd_ptr_ = wr_ptr_ = internal_buffer_ = internal_buffer;
|
||||
buffer_size_ = buffer_size;
|
||||
|
||||
next_ = 0;
|
||||
prev_ = 0;
|
||||
|
||||
address_.clear();
|
||||
}
|
||||
|
||||
|
||||
bool CBuffer::push(const void* ptr, size_t n)
|
||||
{
|
||||
if(NULL != wr_ptr_ && n <= capacity() - length())
|
||||
{
|
||||
memcpy(wr_ptr_, ptr, n);
|
||||
wr_ptr_ += n;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void CBuffer::pop_read_data()
|
||||
{
|
||||
if(NULL != internal_buffer_)
|
||||
{
|
||||
size_t n = length();
|
||||
memmove(internal_buffer_, rd_ptr_, n);
|
||||
wr_ptr_ = internal_buffer_ + n;
|
||||
rd_ptr_ = internal_buffer_;
|
||||
}
|
||||
}
|
||||
78
Server/RylServerProject/BaseLibrary/Stream/Buffer/Buffer.h
Normal file
78
Server/RylServerProject/BaseLibrary/Stream/Buffer/Buffer.h
Normal file
@@ -0,0 +1,78 @@
|
||||
#ifndef _CBUFFER_H_
|
||||
#define _CBUFFER_H_
|
||||
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
|
||||
#include <winsock2.h>
|
||||
#include <windows.h>
|
||||
|
||||
#include "../../Network/Address/INET_Addr.h"
|
||||
|
||||
class CBufferFactory;
|
||||
|
||||
class CBuffer
|
||||
{
|
||||
public:
|
||||
|
||||
CBuffer(CBufferFactory& bufferfactory);
|
||||
~CBuffer();
|
||||
|
||||
void init(char* internal_buffer, unsigned long buffer_size);
|
||||
|
||||
bool is_valid() { return 0 != internal_buffer_; }
|
||||
|
||||
// <20>б<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
char* rd_ptr() const { return rd_ptr_; }
|
||||
void rd_ptr(size_t n) { rd_ptr_ += n; }
|
||||
void rd_ptr(char* ptr) { rd_ptr_ = ptr; }
|
||||
|
||||
// <20>б<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
char* wr_ptr() const { return wr_ptr_; }
|
||||
void wr_ptr(size_t n) { wr_ptr_ += n; }
|
||||
void wr_ptr(char* ptr) { wr_ptr_ = ptr; }
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(past-end) <20><> <20><><EFBFBD><EFBFBD>.
|
||||
char* begin() const { return internal_buffer_; }
|
||||
char* end() const { return internal_buffer_ + buffer_size_; }
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>۷<EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
bool push(const void* ptr, size_t n);
|
||||
|
||||
// <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD><CDB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><> <20><><EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD><CDB5><EFBFBD> <20><>ȿȭ<C8BF><C8AD>.
|
||||
void pop_read_data();
|
||||
|
||||
size_t length() const { return wr_ptr_ - rd_ptr_; } // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
size_t capacity() const { return buffer_size_; } // <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
size_t remain() const { return internal_buffer_ + buffer_size_ - wr_ptr_; } // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
|
||||
CBuffer* next() { return next_; }
|
||||
void next(CBuffer* next) { next_ = next; }
|
||||
|
||||
CBuffer* prev() { return prev_; }
|
||||
void prev(CBuffer* prev) { prev_ = prev; }
|
||||
|
||||
INET_Addr& get_addr() { return address_; }
|
||||
|
||||
CBufferFactory& GetBufferFactory() { return bufferfactory_; }
|
||||
|
||||
private:
|
||||
|
||||
// -----------------------------------------------------------
|
||||
// variable
|
||||
|
||||
char* internal_buffer_;
|
||||
char* rd_ptr_;
|
||||
char* wr_ptr_;
|
||||
size_t buffer_size_;
|
||||
|
||||
CBuffer* next_;
|
||||
CBuffer* prev_;
|
||||
INET_Addr address_;
|
||||
|
||||
CBufferFactory& bufferfactory_;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,307 @@
|
||||
#include "stdafx.h"
|
||||
#include "Buffer.h"
|
||||
#include "BufferFactory.h"
|
||||
|
||||
#include <boost/pool/pool.hpp>
|
||||
#include <boost/pool/object_pool.hpp>
|
||||
|
||||
#include <Log/ServerLog.h>
|
||||
|
||||
|
||||
CBuffer* CBufferFactory::CreateTracking(const char* szRoutine, const char* szFileName, const int nLine, size_t size)
|
||||
{
|
||||
CBuffer* lpBuffer = Create(size);
|
||||
|
||||
g_Log.DetailLog(LOG_DETAIL, szRoutine, szFileName, nLine,
|
||||
"this:%p/BufferAllocate : (0x%p/%d)", this, lpBuffer, size);
|
||||
|
||||
return lpBuffer;
|
||||
};
|
||||
|
||||
void CBufferFactory::ReleaseTracking(const char* szRoutine, const char* szFileName, const int nLine, CBuffer* lpBuffer)
|
||||
{
|
||||
if(0 != lpBuffer)
|
||||
{
|
||||
g_Log.DetailLog(LOG_DETAIL, szRoutine, szFileName, nLine,
|
||||
"this:%p/BufferDeallocate : (0x%p/%d)", this, lpBuffer, lpBuffer->capacity());
|
||||
|
||||
Release(lpBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CBuffer* CDefaultBufferFactory::Create(size_t size)
|
||||
{
|
||||
char* szBuffer = new (std::nothrow) char[size];
|
||||
CBuffer* lpBuffer = new (std::nothrow) CBuffer(*this);
|
||||
|
||||
if(0 != szBuffer && 0 != lpBuffer)
|
||||
{
|
||||
lpBuffer->init(szBuffer, size);
|
||||
return lpBuffer;
|
||||
}
|
||||
|
||||
delete lpBuffer;
|
||||
delete [] szBuffer;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CDefaultBufferFactory::Release(CBuffer* lpBuffer)
|
||||
{
|
||||
if(0 != lpBuffer)
|
||||
{
|
||||
if(0 != lpBuffer->begin())
|
||||
{
|
||||
delete [] lpBuffer->begin();
|
||||
}
|
||||
|
||||
delete lpBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// PoolBufferFactory
|
||||
|
||||
CPoolBufferFactory::CPoolBufferFactory()
|
||||
: m_lpBufferPool(0)
|
||||
{
|
||||
Initialize();
|
||||
}
|
||||
|
||||
CPoolBufferFactory::~CPoolBufferFactory()
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
|
||||
bool CPoolBufferFactory::Initialize()
|
||||
{
|
||||
Destroy();
|
||||
|
||||
BufferLock::Syncronize sync(m_BufferLock);
|
||||
|
||||
m_lpBufferPool = new MemoryPool(sizeof(CBuffer));
|
||||
|
||||
if(0 == m_lpBufferPool)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
const unsigned long MAX_SIZE_ARRAY = 7;
|
||||
unsigned long dwSizeArray[MAX_SIZE_ARRAY] =
|
||||
{
|
||||
1024, 2048, 4096, 8192, 16384, 32768, 65535
|
||||
};
|
||||
|
||||
for(unsigned long dwCount = 0; dwCount < MAX_SIZE_ARRAY; ++dwCount)
|
||||
{
|
||||
MemoryPool* lpMemoryPool = new MemoryPool(dwSizeArray[dwCount]);
|
||||
|
||||
if(0 == lpMemoryPool)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
m_PoolArray.push_back(lpMemoryPool);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
CBuffer* CPoolBufferFactory::Create(size_t size)
|
||||
{
|
||||
BufferLock::Syncronize sync(m_BufferLock);
|
||||
|
||||
if(m_lpBufferPool == 0)
|
||||
return NULL;
|
||||
|
||||
void* ptr = m_lpBufferPool->malloc();
|
||||
CBuffer* lpBuffer = 0;
|
||||
|
||||
if(0 != ptr)
|
||||
{
|
||||
lpBuffer = new (ptr) CBuffer(*this);
|
||||
|
||||
PoolArray::iterator pos = m_PoolArray.begin();
|
||||
PoolArray::iterator end = m_PoolArray.end();
|
||||
|
||||
MemoryPool* lpMemoryPool = 0;
|
||||
char* szBuffer = 0;
|
||||
|
||||
for(; pos != end; ++pos)
|
||||
{
|
||||
lpMemoryPool = (*pos);
|
||||
size_t requested_size = lpMemoryPool->get_requested_size();
|
||||
|
||||
if(size <= requested_size)
|
||||
{
|
||||
szBuffer = reinterpret_cast<char*>(lpMemoryPool->malloc());
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(0 == szBuffer)
|
||||
{
|
||||
szBuffer = new char[size];
|
||||
}
|
||||
|
||||
if(0 != szBuffer)
|
||||
{
|
||||
lpBuffer->init(szBuffer, static_cast<unsigned long>(size));
|
||||
}
|
||||
else
|
||||
{
|
||||
m_lpBufferPool->free(lpBuffer);
|
||||
lpBuffer = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return lpBuffer;
|
||||
}
|
||||
|
||||
|
||||
void CPoolBufferFactory::Release(CBuffer* buffer)
|
||||
{
|
||||
if(0 != buffer)
|
||||
{
|
||||
BufferLock::Syncronize sync(m_BufferLock);
|
||||
|
||||
PoolArray::iterator pos = m_PoolArray.begin();
|
||||
PoolArray::iterator end = m_PoolArray.end();
|
||||
|
||||
MemoryPool* lpMemoryPool = 0;
|
||||
size_t buffer_size = buffer->capacity();
|
||||
|
||||
for(; pos != end; ++pos)
|
||||
{
|
||||
lpMemoryPool = (*pos);
|
||||
size_t requested_size = lpMemoryPool->get_requested_size();
|
||||
|
||||
if(buffer_size <= requested_size)
|
||||
{
|
||||
lpMemoryPool->free(buffer->begin());
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(pos == end)
|
||||
{
|
||||
delete [] buffer->begin();
|
||||
}
|
||||
|
||||
buffer->~CBuffer();
|
||||
m_lpBufferPool->free(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
void CPoolBufferFactory::Destroy()
|
||||
{
|
||||
BufferLock::Syncronize sync(m_BufferLock);
|
||||
|
||||
delete m_lpBufferPool;
|
||||
m_lpBufferPool = 0;
|
||||
|
||||
PoolArray::iterator pos = m_PoolArray.begin();
|
||||
PoolArray::iterator end = m_PoolArray.end();
|
||||
|
||||
for(; pos != end; ++pos)
|
||||
{
|
||||
delete *pos;
|
||||
}
|
||||
|
||||
m_PoolArray.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
void CBufferFactoryTest::DoTest()
|
||||
{
|
||||
#define RealClock(Large_Integer_In) \
|
||||
{ __asm rdtsc __asm mov Large_Integer_In.HighPart, edx __asm mov Large_Integer_In.LowPart, eax }
|
||||
|
||||
const char* const strErrLogFileName = "./PoolErrorLog.txt";
|
||||
|
||||
FILE* lpFile = freopen(strErrLogFileName, "wt", stderr);
|
||||
if(0 == lpFile)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
fprintf(stderr, "%s Test Started.\n", __FUNCTION__);
|
||||
|
||||
LARGE_INTEGER start, stop;
|
||||
double fTime = 0;
|
||||
|
||||
CDefaultBufferFactory bufferFactory;
|
||||
|
||||
const int MAX_LOOP = 10000;
|
||||
|
||||
for(int nBytes = 36; nBytes < 60000; nBytes *= 2)
|
||||
{
|
||||
char* pcBuffer = new char[nBytes];
|
||||
for(int i = 0; i < nBytes; ++i)
|
||||
{
|
||||
pcBuffer[i] = (char)i;
|
||||
}
|
||||
|
||||
CBuffer* pTemp = CREATE_BUFFER(bufferFactory, nBytes);
|
||||
|
||||
fTime = 0;
|
||||
for(int i = 0; i < MAX_LOOP; ++i)
|
||||
{
|
||||
RealClock(start);
|
||||
|
||||
CBuffer* pBuffer = CREATE_BUFFER(bufferFactory, nBytes);
|
||||
|
||||
memcpy(pBuffer->wr_ptr(), pcBuffer, nBytes);
|
||||
pBuffer->wr_ptr(nBytes);
|
||||
|
||||
SAFE_RELEASE_BUFFER(pBuffer);
|
||||
|
||||
RealClock(stop);
|
||||
|
||||
fTime += (double)(stop.QuadPart - start.QuadPart);
|
||||
}
|
||||
fprintf(stderr, "Buffer<EFBFBD>ӵ<EFBFBD> <20><EFBFBD>Ʈ. %dBytes : %f\n", nBytes, fTime/MAX_LOOP);
|
||||
|
||||
fTime = 0;
|
||||
for(int i = 0; i < MAX_LOOP; ++i)
|
||||
{
|
||||
RealClock(start);
|
||||
|
||||
char* pChar = new char[nBytes];
|
||||
memcpy(pChar, pcBuffer, nBytes);
|
||||
delete [] pChar;
|
||||
|
||||
RealClock(stop);
|
||||
|
||||
fTime += (double)(stop.QuadPart - start.QuadPart);
|
||||
}
|
||||
fprintf(stderr, "NewAndDelete %dBytes : %f\n\n", nBytes, fTime/MAX_LOOP);
|
||||
|
||||
SAFE_RELEASE_BUFFER(pTemp);
|
||||
delete [] pcBuffer;
|
||||
}
|
||||
|
||||
fprintf(stderr, "%s Test Completed.\n\n", __FUNCTION__);
|
||||
|
||||
fclose(lpFile);
|
||||
|
||||
#ifdef WIN32
|
||||
char szPath[MAX_PATH];
|
||||
char szFileNameWithPath[MAX_PATH];
|
||||
|
||||
UINT nResult = GetWindowsDirectory(szPath, MAX_PATH);
|
||||
if(0 != nResult && nResult <= MAX_PATH)
|
||||
{
|
||||
_snprintf(szFileNameWithPath, MAX_PATH, "%s\\NotePad.exe %s", szPath, strErrLogFileName);
|
||||
WinExec(szFileNameWithPath, SW_SHOW);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
#ifndef _CBUFFER_FACTORY_H_
|
||||
#define _CBUFFER_FACTORY_H_
|
||||
|
||||
#include <vector>
|
||||
#include <boost/pool/poolfwd.hpp>
|
||||
|
||||
#include "../../Thread/Lock.h"
|
||||
|
||||
//#define DEBUG_BUFFERFACTORY
|
||||
|
||||
#ifdef DEBUG_BUFFERFACTORY
|
||||
#define BUFFER_ARGUMENT __FUNCTION__, __FILE__, __LINE__,
|
||||
#define CREATE_METHOD CreateTracking
|
||||
#define RELEASE_METHOD ReleaseTracking
|
||||
#else
|
||||
#define BUFFER_ARGUMENT
|
||||
#define CREATE_METHOD Create
|
||||
#define RELEASE_METHOD Release
|
||||
#endif
|
||||
|
||||
#define CREATE_BUFFER(instance, size) (instance).CREATE_METHOD(BUFFER_ARGUMENT size)
|
||||
#define SAFE_RELEASE_BUFFER(ptr) if(ptr) { (ptr)->GetBufferFactory().RELEASE_METHOD(BUFFER_ARGUMENT (ptr)); (ptr) = 0; }
|
||||
|
||||
|
||||
// <09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
class CBuffer;
|
||||
|
||||
class CBufferFactory
|
||||
{
|
||||
public:
|
||||
|
||||
virtual ~CBufferFactory() { }
|
||||
|
||||
virtual CBuffer* Create(size_t size) = 0;
|
||||
virtual void Release(CBuffer* lpBuffer) = 0;
|
||||
|
||||
CBuffer* CreateTracking(const char* szRoutine, const char* szFileName, const int nLine, size_t size);
|
||||
void ReleaseTracking(const char* szRoutine, const char* szFileName, const int nLine, CBuffer* lpBuffer);
|
||||
};
|
||||
|
||||
|
||||
class CDefaultBufferFactory : public CBufferFactory
|
||||
{
|
||||
public:
|
||||
|
||||
virtual CBuffer* Create(size_t size);
|
||||
virtual void Release(CBuffer* lpBuffer);
|
||||
};
|
||||
|
||||
|
||||
class CPoolBufferFactory : public CBufferFactory
|
||||
{
|
||||
public:
|
||||
|
||||
CPoolBufferFactory();
|
||||
virtual ~CPoolBufferFactory();
|
||||
|
||||
virtual CBuffer* Create(size_t size);
|
||||
virtual void Release(CBuffer* lpBuffer);
|
||||
|
||||
void Destroy();
|
||||
|
||||
protected:
|
||||
|
||||
bool Initialize();
|
||||
|
||||
typedef boost::pool<> MemoryPool;
|
||||
|
||||
typedef std::vector<MemoryPool*> PoolArray;
|
||||
typedef CCSLock BufferLock;
|
||||
|
||||
BufferLock m_BufferLock;
|
||||
MemoryPool* m_lpBufferPool;
|
||||
PoolArray m_PoolArray;
|
||||
};
|
||||
|
||||
|
||||
class CBufferFactoryTest
|
||||
{
|
||||
public:
|
||||
void DoTest();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,194 @@
|
||||
#include "stdafx.h"
|
||||
#include "Buffer.h"
|
||||
#include "BufferQueue.h"
|
||||
#include "BufferFactory.h"
|
||||
|
||||
CBufferQueue::CBufferQueue()
|
||||
: m_lpHead(0),
|
||||
m_lpTail(0),
|
||||
m_bufferNum(0),
|
||||
m_queueSize(0),
|
||||
m_maxQueueSize(0xFFFFFFFF)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
CBufferQueue::~CBufferQueue()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
|
||||
bool CBufferQueue::enqueue(CBuffer* lpBuffer, bool bPendHead)
|
||||
{
|
||||
if(0 != lpBuffer)
|
||||
{
|
||||
size_t bufferUsage = lpBuffer->length();
|
||||
|
||||
if(m_queueSize + bufferUsage < m_maxQueueSize)
|
||||
{
|
||||
if(0 == m_lpHead)
|
||||
{
|
||||
m_lpHead = m_lpTail = lpBuffer;
|
||||
}
|
||||
else if(!bPendHead)
|
||||
{
|
||||
m_lpTail->next(lpBuffer);
|
||||
lpBuffer->prev(m_lpTail);
|
||||
|
||||
m_lpTail = lpBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
lpBuffer->next(m_lpHead);
|
||||
m_lpHead->prev(lpBuffer);
|
||||
|
||||
m_lpHead = lpBuffer;
|
||||
}
|
||||
|
||||
++m_bufferNum;
|
||||
m_queueSize += bufferUsage;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
CBuffer* CBufferQueue::dequeue()
|
||||
{
|
||||
CBuffer* lpBuffer = 0;
|
||||
|
||||
if(0 != m_lpHead)
|
||||
{
|
||||
lpBuffer = m_lpHead;
|
||||
m_lpHead = m_lpHead->next();
|
||||
|
||||
lpBuffer->prev(0);
|
||||
lpBuffer->next(0);
|
||||
|
||||
if(m_lpTail == lpBuffer)
|
||||
{
|
||||
m_lpTail = 0;
|
||||
}
|
||||
|
||||
--m_bufferNum;
|
||||
m_queueSize -= lpBuffer->length();
|
||||
}
|
||||
|
||||
return lpBuffer;
|
||||
}
|
||||
|
||||
|
||||
void CBufferQueue::clear()
|
||||
{
|
||||
CBuffer* lpDelete = 0;
|
||||
|
||||
while(0 != m_lpHead)
|
||||
{
|
||||
lpDelete = m_lpHead;
|
||||
m_lpHead = m_lpHead->next();
|
||||
|
||||
SAFE_RELEASE_BUFFER(lpDelete);
|
||||
}
|
||||
|
||||
m_lpTail = 0;
|
||||
m_bufferNum = 0;
|
||||
m_queueSize = 0;
|
||||
}
|
||||
|
||||
void CBufferQueue::splice(CBufferQueue& Buffer_In, bool bPendHead)
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> BufferQueue<75><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> BufferQueue<75><65> <20><><EFBFBD>δ<EFBFBD>.
|
||||
if(0 != Buffer_In.m_lpHead)
|
||||
{
|
||||
if(0 == m_lpHead)
|
||||
{
|
||||
m_lpHead = Buffer_In.m_lpHead;
|
||||
m_lpTail = Buffer_In.m_lpTail;
|
||||
}
|
||||
else if(!bPendHead)
|
||||
{
|
||||
m_lpTail->next(Buffer_In.m_lpHead);
|
||||
Buffer_In.m_lpHead->prev(m_lpTail);
|
||||
|
||||
m_lpTail = Buffer_In.m_lpTail;
|
||||
}
|
||||
else
|
||||
{
|
||||
Buffer_In.m_lpTail->next(m_lpHead);
|
||||
m_lpHead->prev(Buffer_In.m_lpTail);
|
||||
|
||||
m_lpHead = Buffer_In.m_lpHead;
|
||||
}
|
||||
|
||||
m_bufferNum += Buffer_In.getBufferNum();
|
||||
m_queueSize += Buffer_In.getQueueSize();
|
||||
|
||||
Buffer_In.m_lpHead = 0;
|
||||
Buffer_In.m_lpTail = 0;
|
||||
Buffer_In.m_bufferNum = 0;
|
||||
Buffer_In.m_queueSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void CBufferQueue::splice_n(CBufferQueue& Buffer_In, unsigned long dwSpliceNum, bool bPendHead)
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> BufferQueue<75><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20>ִ<EFBFBD> dwSpliceNum<75><6D> <20><>ŭ<EFBFBD><C5AD> <20><> BufferQueue<75><65> <20><><EFBFBD>δ<EFBFBD>.
|
||||
if (Buffer_In.getBufferNum() <= dwSpliceNum)
|
||||
{
|
||||
// <20>ִ밳<D6B4><EBB0B3> <20≯<EFBFBD><CCB8≯<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>δ<EFBFBD>.
|
||||
splice(Buffer_In, bPendHead);
|
||||
}
|
||||
else if(0 != Buffer_In.m_lpHead)
|
||||
{
|
||||
// <20>ִ밳<D6B4><EBB0B3> <20>̻<EFBFBD><CCBB><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>, <20>ϴ<EFBFBD> Ž<><C5BD> <20><><EFBFBD><EFBFBD><EEB0A1> <20>߶<DFB6>.
|
||||
|
||||
unsigned long dwBufferNum = 0; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
unsigned long dwQueueSize = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(byte)
|
||||
|
||||
CBuffer* lpNewBufferHead = Buffer_In.m_lpHead;
|
||||
|
||||
for(; dwBufferNum < dwSpliceNum; ++dwBufferNum)
|
||||
{
|
||||
dwQueueSize += lpNewBufferHead->length();
|
||||
lpNewBufferHead = lpNewBufferHead->next();
|
||||
}
|
||||
|
||||
// <20>յڸ<D5B5> <20>߶<DFB6>.
|
||||
CBuffer* lpSplicedHead = Buffer_In.m_lpHead;
|
||||
CBuffer* lpSplicedTail = lpNewBufferHead;
|
||||
|
||||
Buffer_In.m_lpHead = lpSplicedTail->next();
|
||||
Buffer_In.m_lpHead->prev(0);
|
||||
lpSplicedTail->next(0);
|
||||
|
||||
Buffer_In.m_bufferNum -= dwBufferNum;
|
||||
Buffer_In.m_queueSize -= dwQueueSize;
|
||||
|
||||
if(0 == m_lpHead)
|
||||
{
|
||||
m_lpHead = lpSplicedHead;
|
||||
m_lpTail = lpSplicedTail;
|
||||
}
|
||||
else if(!bPendHead)
|
||||
{
|
||||
m_lpTail->next(lpSplicedHead);
|
||||
lpSplicedHead->prev(m_lpTail);
|
||||
|
||||
m_lpTail = lpSplicedTail;
|
||||
}
|
||||
else
|
||||
{
|
||||
lpSplicedTail->next(m_lpHead);
|
||||
m_lpHead->prev(lpSplicedTail);
|
||||
|
||||
m_lpHead = lpSplicedHead;
|
||||
}
|
||||
|
||||
m_bufferNum += dwBufferNum;
|
||||
m_queueSize += dwQueueSize;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
#ifndef _GAMA_SERVER_LIB_BUFFER_QUEUE_H_
|
||||
#define _GAMA_SERVER_LIB_BUFFER_QUEUE_H_
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
#include <list>
|
||||
|
||||
class CBuffer;
|
||||
|
||||
class CBufferQueue
|
||||
{
|
||||
public:
|
||||
|
||||
CBufferQueue();
|
||||
virtual ~CBufferQueue();
|
||||
|
||||
void setMaxQueueSize(unsigned long dwMaxQueueSize) { m_maxQueueSize = dwMaxQueueSize; }
|
||||
|
||||
bool enqueue(CBuffer* lpBuffer, bool bPendHead = false);
|
||||
CBuffer* dequeue();
|
||||
|
||||
void splice(CBufferQueue& Buffer_In, bool bPendHead = false);
|
||||
void splice_n(CBufferQueue& Buffer_In, unsigned long dwSpliceNum, bool bPendHead = false);
|
||||
|
||||
void clear();
|
||||
|
||||
CBuffer* getHead() { return m_lpHead; }
|
||||
|
||||
bool empty() const { return 0 == m_bufferNum; }
|
||||
size_t getQueueSize() const { return m_queueSize; }
|
||||
size_t getBufferNum() const { return m_bufferNum; }
|
||||
|
||||
private:
|
||||
|
||||
CBuffer* m_lpHead;
|
||||
CBuffer* m_lpTail;
|
||||
|
||||
size_t m_bufferNum;
|
||||
size_t m_queueSize;
|
||||
size_t m_maxQueueSize;
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user