一个读写缓冲模块

<pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define ARG_IS_VALID(exr, ret) do\
{\
    if (!(exr))\
    {\
        printf("invalid argument: failed to jugde %s\n", #exr);\
        return ret;\
    }\
}while(0)

#define SUCCESS 0
#define FAILURE -1
#define _Free(arg) __Free((void**)arg)

typedef struct TAG_READ_BUFF_T
{
    int ReadPosition;
    int WritePosition;
    int BuffSize;
    void* Begin;
}READ_BUFF_T;

void* _Malloc(int bytes)
{
    ARG_IS_VALID(bytes > 0, NULL);
    int AlignSize = _Align(bytes);
    void* ret = malloc(AlignSize);
    if (NULL != ret)
    {
        memset(ret, 0, AlignSize);
    }else
    {
        printf("malloc error.size: %d\n", AlignSize);
    }
    return ret;
}

int __Free(void** ptr)
{
    ARG_IS_VALID(NULL != ptr, FAILURE);
    ARG_IS_VALID(NULL != (*ptr), FAILURE);
    free(*ptr);
    *ptr = NULL;
    return SUCCESS;
}

static int __GetBufWritable(READ_BUFF_T* pReadBuf, void** Begin, int* Len)
{
    ARG_IS_VALID(NULL != pReadBuf, FALURE);
    ARG_IS_VALID(NULL != Begin, FALURE);
    ARG_IS_VALID(NULL != Len, FALURE);
    *Begin = pReadBuf->Begin + pReadBuf->WritePosition;
    *Len = pReadBuf->BuffSize - pReadBuf->WritePosition;
    printf("buffer has %d blank space.\n", *Len);
    return SUCCESS;
}

static int __GetBufReadable(READ_BUFF_T* pReadBuf, void** Begin, int* Len)
{
    ARG_IS_VALID(NULL != pReadBuf, FALURE);
    ARG_IS_VALID(NULL != Begin, FALURE);
    ARG_IS_VALID(NULL != Len, FALURE);
    *Begin = pReadBuf->Begin + pReadBuf->ReadPosition;
    *Len = pReadBuf->WritePosition - pReadBuf->ReadPosition;
    printf("buffer has %d bytes space need to read.\n", *Len);
    return SUCCESS;
}

static int __ResetWritablePosition(READ_BUFF_T* pReadBuf, int length)
{
    ARG_IS_VALID(NULL != pReadBuf, FALURE);
    ARG_IS_VALID(length <= pReadBuf->BuffSize - pReadBuf->WritePosition, FALURE);
    pReadBuf->WritePosition += length;
    return SUCCESS;
}

static int __ResetReadablePosition(READ_BUFF_T* pReadBuf, int length)
{
    ARG_IS_VALID(NULL != pReadBuf, FALURE);
    ARG_IS_VALID(length <= pReadBuf->WritePosition - pReadBuf->ReadPosition, FALURE);
    pReadBuf->ReadPosition += length;
    return SUCCESS;
}

static int __ReserveBuff(READ_BUFF_T* pReadBuf, int length)
{
    ARG_IS_VALID(NULL != pReadBuf, FALURE);
    ARG_IS_VALID(length <= pReadBuf->BuffSize, FALURE);
    if (pReadBuf->BuffSize - pReadBuf->WritePosition >= length)
    {
    }
    else if (pReadBuf->BuffSize - pReadBuf->WritePosition + pReadBuf->ReadPosition >= length)
    {
        memmove(pReadBuf->Begin, pReadBuf->Begin+ pReadBuf->ReadPosition, pReadBuf->WritePosition - pReadBuf->ReadPosition);
        pReadBuf->WritePosition -= pReadBuf->ReadPosition;
        pReadBuf->ReadPosition = 0;
    }else
    {
        printf("no enough reserve buffer[%d bytes]\n", length);
        return FALURE;
    }
    return SUCCESS;
}

static READ_BUFF_T* READ_BUFF_Init(int BuffSize)
{
    ARG_IS_VALID(BuffSize > 0, NULL);
    READ_BUFF_T* pstReadBuff = (READ_BUFF_T*)AJB_Malloc(sizeof(READ_BUFF_T) + BuffSize);
    EX_ASSERT(NULL != pstReadBuff);
    pstReadBuff->BuffSize = BuffSize;
    pstReadBuff->ReadPosition = 0;
    pstReadBuff->WritePosition = 0;
    pstReadBuff->Begin = (void*)(pstReadBuff+1);
    printf("read buffer init completed.size: %d\n", BuffSize);

    return pstReadBuff;
}

static int READ_BUFF_Destroy(READ_BUFF_T** pstReadBuff)
{
    ARG_IS_VALID(NULL != pstReadBuff, FALURE);
    ARG_IS_VALID(NULL != *pstReadBuff, FALURE);
    AJB_Free(pstReadBuff);
    printf("destroy read buff completed.pstReadBuff: 0x%p\n", *pstReadBuff);
    return SUCCESS;
}