void CCBuffer::reset()
{
moveWriterIndexToFront();
moveReaderIndexToFront();
DO_ASSIGN(_u_mark_pos, 0);
DO_ASSIGN(_u_content_size, 0);
}
void CCBuffer::clear()
{
DO_ASSIGN(_u_content_size, 0);
DO_ASSIGN(_u_write_pos, 0);
DO_ASSIGN(_u_read_pos, 0);
DO_ASSIGN(_u_mark_pos, 0);
memset(_p_buffer, 0, _u_buffer_size);
}
CCBuffer::CCBuffer(unsigned int n_capacity)
: _p_buffer(NULL)
, _u_write_pos(0)
, _u_read_pos(0)
, _u_content_size(0)
, _u_mark_pos(0)
{
DO_ASSIGN(_u_buffer_size, n_capacity);
DO_ASSIGN(_p_buffer, (char*) malloc(_u_buffer_size));
}
CCBuffer::CCBuffer(const char* p_data, unsigned int u_len)
: _p_buffer(NULL)
, _u_read_pos(0)
, _u_mark_pos(0)
{
DO_ASSERT(p_data && LD(u_len, 0), "p_data && u_len > 0");
DO_ASSIGN(_u_buffer_size, u_len);
DO_ASSIGN(_u_write_pos, u_len);
DO_ASSIGN(_u_content_size, u_len);
DO_ASSIGN(_p_buffer, (char*) malloc(u_len));
memcpy(_p_buffer, p_data, u_len);
}
void CCBuffer::writeChar(char data)
{
_reallocBufferSizeInChanged(sizeof(char));
DO_ASSIGN(QV(CA(_p_buffer, _u_write_pos)), data);
AAI(_u_write_pos);
MAXA(_u_content_size, _u_write_pos);
}
Ref* CCBuffer::copy()
{
BEGIN_IF(LD(_u_content_size, 0))
DO_ASSIGN(CCBuffer* p_buf, new CCBuffer(_p_buffer, _u_content_size));
DO_RETURN_R(p_buf);
BEGIN_ELSE
DO_RETURN_NULL;
END_IF
}
void CCBuffer::moveLeft(unsigned int u_len)
{
BEGIN_IF(LE(_u_content_size, 0))
DO_RETURN;
END_IF
DO_ASSERT(LNE(u_len, 0), "LNE(u_len, 0)");
BEGIN_IF(LDE(u_len, _u_content_size)) clear();
BEGIN_ELSE
BEGIN_FOR(DO_ASSIGN(unsigned int i, u_len), LX(i, _u_content_size), AAI(i))
DO_ASSIGN(QV(CA(_p_buffer, CS(i, u_len))), QV(CA(_p_buffer, i)));
DO_ASSIGN(QV(CA(_p_buffer, i)), 0);
END_FOR
DO_ASSIGN(_u_write_pos, TO_UINT(MAX(0, CS(TO_INT(_u_write_pos), TO_INT(u_len)))));
DO_ASSIGN(_u_read_pos, TO_UINT(MAX(0, CS(TO_INT(_u_read_pos), TO_INT(u_len)))));
DO_ASSIGN(_u_mark_pos, TO_UINT(MAX(0, CS(TO_INT(_u_mark_pos), TO_INT(u_len)))));
DO_ASSIGN(_u_content_size, CS(_u_content_size, u_len));
END_IF
}
void CCBuffer::moveWriterIndexToBack()
{
DO_ASSIGN(_u_write_pos, _u_content_size);
}
NS_CC_BEGIN
#ifndef JASON_LEE_LANGUAGE
#define JASON_LEE_LANGUAGE
#define BEGIN_IF(con) if(con) {
#define BEGIN_ELSE_IF(con) } else if(con) {
#define BEGIN_ELSE } else {
#define END_IF }
#define BEGIN_WHILE_TRUE while(true) {
#define BEGIN_WHILE(con) while(con) {
#define END_WHILE }
#define BEGIN_DO_WHILE do {
#define END_DO_WHILE(con) } while(con);
#define END_DO_WHILE_TRUE } while(true);
#define BEGIN_FOR(a,con,c) for(a;con;c) {
#define BEGIN_FOR_TRUE(a,c) for(a;true;c) {
#define END_FOR }
#define DO_CONTINUE continue
#define DO_BREAK break
#define DO_ASSIGN(n,v) n = v
#define DO_ASSERT(c,m) CCAssert(c,m)
#define DO_RETURN_R(r) return r
#define DO_RETURN_FLASE return false
#define DO_RETURN_TRUE return true
#define DO_RETURN_NULL return NULL
#define DO_RETURN_Z return 0
#define DO_RETURN return
#define R_FALSE false
#define R_TRUE true
#define TO_SHORT(a) ((short)a)
#define TO_USHORT(a) ((unsigned short)a)
#define TO_INT(a) ((int)a)
#define TO_UINT(a) ((unsigned int)a)
#define IAA(a) a++
#define AAI(a) ++a
#define ISS(a) a--
#define SSI(a) --a
#define CA(a,b) (a + b)
#define CS(a,b) (a - b)
#define CM(a,b) (a * b)
#define CD(a,b) (a / b)
#define LX(a,b) (a < b)
#define LD(a,b) (a > b)
#define LE(a,b) (a == b)
#define LXE(a,b) (a <= b)
#define LDE(a,b) (a >= b)
#define LNE(a,b) (a != b)
#define LQ(a,b) (a && b)
#define LH(a,b) (a || b)
#define AA(a,b) (a += b)
#define AS(a,b) (a -= b)
#define AM(a,b) (a *= b)
#define AD(a,b) a = a / b
#define MAXA(a,b) a = (((a) < (b)) ? (b) : (a))
#define MINA(a,b) a = (((a) < (b)) ? (a) : (b))
#define QV(a) *(a)
#define QZ(a) &(a)
#endif //JASON_LEE_LANGUAGE
CCBuffer::CCBuffer()
: _p_buffer(NULL)
, _u_write_pos(0)
, _u_read_pos(0)
, _u_content_size(0)
, _u_buffer_size(CCBUFFER_ORGINAL_SIZE)
, _u_mark_pos(0)
{
DO_ASSIGN(_p_buffer, (char*) malloc(_u_buffer_size));
}
void CCBuffer::setWriterIndex(unsigned int u_pos)
{
DO_ASSERT(LXE(u_pos, _u_content_size), "LXE(u_pos, _u_content_size)");
DO_ASSIGN(_u_write_pos, u_pos);
}
void CCBuffer::resetReaderIndex()
{
DO_ASSIGN(_u_read_pos, _u_mark_pos);
}
CCBuffer* CCBuffer::create()
{
DO_ASSIGN(CCBuffer* pRet, new CCBuffer());
pRet->autorelease();
DO_RETURN_R(pRet);
}
void CCBuffer::moveReaderIndexToBack()
{
DO_ASSIGN(_u_read_pos, _u_content_size);
}
void Buffer::setReaderIndex(unsigned int u_pos)
{
DO_ASSERT(LXE(u_pos, _u_content_size), "LXE(u_pos, _u_content_size)");
DO_ASSIGN(_u_read_pos, u_pos);
}
void CCBuffer::_reallocBufferSize()
{
DO_ASSIGN(_u_buffer_size, CM(_u_buffer_size, 2));
DO_ASSIGN(_p_buffer, (char*) realloc(_p_buffer, _u_buffer_size));
}
void CCBuffer::moveWriterIndexToFront()
{
DO_ASSIGN(_u_write_pos, 0);
}
CCBuffer* CCBuffer::create(const char* p_data, unsigned int u_len)
{
DO_ASSIGN(CCBuffer* pRet, new CCBuffer(p_data, u_len));
pRet->autorelease();
DO_RETURN_R(pRet);
}
CCBuffer* CCBuffer::create(unsigned int n_capacity)
{
DO_ASSIGN(CCBuffer* pRet, new CCBuffer(n_capacity));
pRet->autorelease();
DO_RETURN_R(pRet);
}
void CCBuffer::moveReaderIndexToFront()
{
DO_ASSIGN(_u_read_pos, 0);
}
void Buffer::markReaderIndex()
{
DO_ASSIGN(_u_mark_pos, _u_read_pos);
}
