网络收发之cycleBuf

#pragma once

#include <iostream>
#include <string>

class cyclebuffer
{
protected:
    volatile int32_t  m_nReadIndex;
    volatile int32_t  m_nWriteIndex;
    volatile int32_t  m_nDataSize;    //有效数据大小
    volatile int32_t  m_nBufSize;    //总buf大小
    uint_8               *m_pBuf;

public:
    cyclebuffer(int nBufSize)
    {
        Reset();
        m_pBuf = (uint8_t *)malloc(nBufSize);
        m_nbufSize = nBufSize;
    }
        
    virtual ~cyclebuffer()
    {
        if(m_pBuf != NULL)
        {
            free(m_pBuf);
            m_pBuf = NULL;
        }
    }

    //剩余空间数
    int32_t Space()
    {
        return m_nBufSize-m_nDataSize;
    }

    //获取buf的总大小
    int32_t  Capatity()
    {
        return m_nBufSize;
    }
    
    //获取有效数据长度
    int32_t Size()
    {
        return m_nDataSize;
    }

    //清空
    void Reset()
    {
        m_nReadIndex = 0;
        m_nwriteIndex = 0;
        m_nDataSize   = 0;
    }
    
    //增加nSize个字节
    int32_t  Grow(int32_t nSize)
    {
        if(nSize<=0)
        {
            return 0;
        }

        uint8_t *pMem = (uint8_t *)malloc(nSize + m_nBufSize);
        if(pMem == NULL)
        {
            return 0;
        }

        int32_t nWriteIndex = 0;
        //将旧内存中的数据拷贝到（增大的）新内存中
        do
        {
            int32_t nReadBytes = Read(pMem + nWriteIndex, 4096);
            if(nReadBytes <= 0)
            {
                break;
            }
            nWriteIndex += nReadBytes;
        }while(m_nDataSize > 0);
        
        if(m_nDataSize > 0)
        {
            return -1;
        }
        
        //释放旧内存块
        if(m_pBuf != NULL)
        {
            free(m_pBuf);
        }

        m_pBuf = pMem;
        m_nReadIndex = 0;
        m_nWriteIndex = nWriteIndex;
        m_nDataSize   = nWriteIndex;
        m_nBufSize   += nSize;

        return nSize;
    }

    //写到写列表的头部---针对新数据
    int32_t WriteToHead(const uint8_t *pBuf, int32_t nDataSize)
    {
        if(nDataSize < 0 || pBuf == NULL)
        {
            return 0;
        }
    
        //空间不够
        if(m_nDataSize + nDataSize > m_nBufsize)
        {
            if(Grow((m_nDataSize+nDataSize) - m_nDataSize) <= 0)
            {
                return 0;
            }
        }

        if(m_nWriteIndex < m_nReadIndex)
        {
            memcpy(&m_pBuf[m_nReadIndex-nDataSize], pBuf, nDataSize);
            m_nReadIndex -= nDataSize;
        }
        else if(m_nWriteIndex == m_nReadIndex)
        {
            return Write(pBuf, nDataSize);
        }
        else
        {
            int32_t nLeftDataSize = (nDataSize-m_nReadIndex<0)?nDataSize:m_nReadIndex;
            if(nLeftDataSize < nDataSize)    //此时nLeftDataSize == m_nReadIndex,m_nReadIndex前面的空间不够
            {
                int32_t nTailDataSize = nDataSize - nLeftDataSize;
                int32_t nWriteIndex   = m_nBufSize - nTailDatasize;
                memcpy(&m_pBuf[nWriteIndex], pBuf, nDataSize-nLeftDataSize);  //从内存最后向前写
                memcpy(&m_pBuf[0], pBuf+nTailDataSize, nLeftDataSize);
                m_nReadIndex = nWriteIndex;
            }
            else
            {
                if(m_nReadIndex-nDataSize < 0)
                {
                    return 0;
                }
                memcpy(&m_pBuf[m_nReadIndex-nDataSize], pBuf, nDataSize);
                m_nReadIndex -= nDataSize;
            }
        }

        m_nDataSize += nDataSize;
        return nDataSize;
    }

    //写到列表的尾部
    int32_t Write(const uint8_t *pBuf, int32_t nDataSize)
    {
        if(nDataSize <= 0 || NULL == pBuf)
        {
            return 0;
        }
        
        if(nDataSize + m_nDataSize > m_nBufSize)
        {
            if(Grow((nDataSize+nBufSize)-m_nDataSize) <= 0)
            {
                return 0;
            }
        }
    
        if(m_nWriteIndex < m_nReadIndex)
        {
            memcpy(&m_pBuf[m_nWriteIndex], pBuf, nDataSize);
            m_nWriteIndex += nDataSize;
        }
        else
        {
            int32_t nLeftDataSize = m_nBufSize - m_nWriteIndex;
            if(nLeftDataSize < nDataSize)
            {
                memcpy(&m_pBuf[m_nWriteIndex], pBuf, nLeftDataSize);
                memcpy(&m_pBuf[0], pBuf+nLeftDataSize, nDataSize-nLeftDataSize);
                m_nwriteIndex = nDataSize - nLeftDataSize;
            }
            else
            {
                memcpy(&m_pBuf[m_nWriteIndex], pBuf, nDataSize);
                m_nWriteIndex += nDataSize;
            }
        }
        m_nDataSize += nDataSize;
        return nDataSize;
    }

    //读取 读列表的头部内存
    int32_t Read(uint8_t *pBuf, const int32_t nWantSize)
    {
        if(nWantSize <= 0 || NULL == pBuf)
        {
            return 0;
        }

        int32_t nDataSize = ((m_nDataSize < nWantSize)?m_nDataSize : nWantSize);
        if(nDataSize<=0)
        {
            return 0;
        }

        if(m_nReadIndex < m_nWriteIndex)
        {
            memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
            m_nReadIndex += nDataSize;
        }
        else
        {
            int32_t nLeftDataSize = m_nBufSize - m_nReadIndex;
            if(nLeftDataSize < nDataSize)
            {
                memcpy(pBuf, &m_pBuf[m_nReadIndex], nLeftDataSize);
                memcpy(pBuf+nLeftDataSize, &m_pBuf[0], nDataSize-nLeftDataSize);
                m_nReadIndex = nDataSize-nLeftDataSize;
            }
            else
            {
                memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
                m_nReadIndex += nDataSize;
            }
        }
        m_nDataSize -= nDataSize;
        return nDataSize;
    }


    //读取数据但是不修改读索引
    int32_t  PeekRead(uint8_t *pBuf, const int32_t nWantSize)
    {
        if(nWantSize <= 0 || pBuf == NULL)
        {
            return 0;
        }

        int32_t  nDataSize = ((m_nDataSize < nWantSize) ? m_nDataSize : nWantSize);
        if(m_nReadIndex < m_nWriteIndex)
        {
            memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
        }
        else if(m_nReadIndex == m_nWriteIndex)
        {
            return 0;
        }
        else
        {
            int32_t nLeftDataSize = m_nBufSize - m_nReadIndex;
            if(nLeftDataSize < nDataSize)
            {
                memcpy(pBuf, &m_pBuf[m_nReadIndex], nLeftDataSize);
                memcpy(pBuf+nLeftDataSize, &m_pBuf[0], nDataSize-nLeftDataSize);
            }
            else
            {
                memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
            }
        }
        return  nDataSize;
    }
    
};