网络收发之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 = ;
         m_nwriteIndex = ;
         m_nDataSize   = ;
     }

     //增加nSize个字节
     int32_t  Grow(int32_t nSize)
     {
         if(nSize<=)
         {
             return ;
         }

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

         int32_t nWriteIndex = ;
         //将旧内存中的数据拷贝到（增大的）新内存中
         do
         {
             int32_t nReadBytes = Read(pMem + nWriteIndex, );
             if(nReadBytes <= )
             {
                 break;
             }
             nWriteIndex += nReadBytes;
         }while(m_nDataSize > );

         if(m_nDataSize > )
         {
             return -;
         }

         //释放旧内存块
         if(m_pBuf != NULL)
         {
             free(m_pBuf);
         }

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

         return nSize;
     }

     //写到写列表的头部---针对新数据
     int32_t WriteToHead(const uint8_t *pBuf, int32_t nDataSize)
     {
         if(nDataSize <  || pBuf == NULL)
         {
             return ;
         }

         //空间不够
         if(m_nDataSize + nDataSize > m_nBufsize)
         {
             if(Grow((m_nDataSize+nDataSize) - m_nDataSize) <= )
             {
                 return ;
             }
         }

         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<)?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[], pBuf+nTailDataSize, nLeftDataSize);
                 m_nReadIndex = nWriteIndex;
             }
             else
             {
                 if(m_nReadIndex-nDataSize < )
                 {
                     return ;
                 }
                 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 <=  || NULL == pBuf)
         {
             return ;
         }

         if(nDataSize + m_nDataSize > m_nBufSize)
         {
             if(Grow((nDataSize+nBufSize)-m_nDataSize) <= )
             {
                 return ;
             }
         }

         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[], 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 <=  || NULL == pBuf)
         {
             return ;
         }

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

         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[], 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 <=  || pBuf == NULL)
         {
             return ;
         }

         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 ;
         }
         else
         {
             int32_t nLeftDataSize = m_nBufSize - m_nReadIndex;
             if(nLeftDataSize < nDataSize)
             {
                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nLeftDataSize);
                 memcpy(pBuf+nLeftDataSize, &m_pBuf[], nDataSize-nLeftDataSize);
             }
             else
             {
                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
             }
         }
         return  nDataSize;
     }

 };