网络收发之cycleBuf

  1 #pragma once
  2 
  3 #include <iostream>
  4 #include <string>
  5 
  6 class cyclebuffer
  7 {
  8 protected:
  9     volatile int32_t  m_nReadIndex;
 10     volatile int32_t  m_nWriteIndex;
 11     volatile int32_t  m_nDataSize;  //有效数据大小
 12     volatile int32_t  m_nBufSize;   //总buf大小
 13     uint_8            *m_pBuf;
 14 
 15 public:
 16     //剩余空间数
 17     int32_t Space()
 18     {   
 19         return m_nBufSize-m_nDataSize;
 20     }   
 21 
 22     //获取buf的总大小
 23     int32_t  Capatity()
 24     {   
 25         return m_nBufSize;
 26     }   
 27        
 28     //获取有效数据长度
 29     int32_t Size()
 30     {   
 31         return m_nDataSize;
 32     }   
 33     //清空
 34     void Reset()
 35     {
 36         m_nReadIndex = 0;
 37         m_nwriteIndex = 0;
 38         m_nDataSize   = 0;
 39     }
 40    
 41     //增加nSize个字节
 42     int32_t  Grow(int32_t nSize)
 43     {
 44 
 45     }
 46 
 47     //写到写列表的头部---针对新数据
 48     int32_t WriteToHead(const uint8_t *pBuf, int32_t nDataSize)
 49     {
 50         if(nDataSize < 0 || pBuf == NULL)
 51         {
 52             return 0;
 53         }
 54    
 55         //空间不够
 56         if(m_nDataSize + nDataSize > m_nBufsize)
 57         {
 58             if(Grow((m_nDataSize+nDataSize) - m_nDataSize) <= 0)
 59             {
 60                 return 0;
 61             }
 62         }
 63 
 64         if(m_nWriteIndex < m_nReadIndex)
 65         {
 66             memcpy(&m_pBuf[m_nReadIndex-nDataSize], pBuf, nDataSize);
 67             m_nReadIndex -= nDataSize;
 68         }
 69         else if(m_nWriteIndex == m_nReadIndex)
 70         {
 71             return Write(pBuf, nDataSize);
 72         }
 73         else
 74         {
 75             int32_t nLeftDataSize = (nDataSize-m_nReadIndex<0)?nDataSize:m_nReadIndex;
 76             if(nLeftDataSize < nDataSize)   //此时nLeftDataSize == m_nReadIndex,m_nReadIndex前面的空间不够
 77             {
 78                 int32_t nTailDataSize = nDataSize - nLeftDataSize;
 79                 int32_t nWriteIndex   = m_nBufSize - nTailDatasize;
 80                 memcpy(&m_pBuf[nWriteIndex], pBuf, nDataSize-nLeftDataSize);  //从内存最后向前写
 81                 memcpy(&m_pBuf[0], pBuf+nTailDataSize, nLeftDataSize);
 82                 m_nReadIndex = nWriteIndex;
 83             }
 84             else
 85             {
 86                 if(m_nReadIndex-nDataSize < 0)
 87                 {
 88                     return 0;
 89                 }
 90                 memcpy(&m_pBuf[m_nReadIndex-nDataSize], pBuf, nDataSize);
 91                 m_nReadIndex -= nDataSize;
 92             }
 93         }
 94         m_nDataSize += nDataSize;
 95         return nDataSize;
 96     }
 97 
 98     //写到列表的尾部
 99     int32_t Write(const uint8_t *pBuf, int32_t nDataSize)
100     {
101         if(nDataSize <= 0 || NULL == pBuf)
102         {
103             return 0;
104         }
105 
106         if(nDataSize + m_nDataSize > m_nBufSize)
107         {
108             if(Grow((nDataSize+nBufSize)-m_nDataSize) <= 0)
109             {
110                 return 0;
111             }
112         }
113    
114         if(m_nWriteIndex < m_nReadIndex)
115         {
116             memcpy(&m_pBuf[m_nWriteIndex], pBuf, nDataSize);
117             m_nWriteIndex += nDataSize;
118         }
119         else
120         {
121             int32_t nLeftDataSize = m_nBufSize - m_nWriteIndex;
122             if(nLeftDataSize < nDataSize)
123             {
124         {
125                 memcpy(&m_pBuf[m_nWriteIndex], pBuf, nLeftDataSize);
126                 memcpy(&m_pBuf[0], pBuf+nLeftDataSize, nDataSize-nLeftDataSize);
127                 m_nwriteIndex = nDataSize - nLeftDataSize;
128             }
129             else
130             {
131                 memcpy(&m_pBuf[m_nWriteIndex], pBuf, nDataSize);
132                 m_nWriteIndex += nDataSize;
133             }
134         }
135         m_nDataSize += nDataSize;
136         return nDataSize;
137     }
138 
139     //读取 读列表的头部内存
140     int32_t Read(uint8_t *pBuf, const int32_t nWantSize)
141     {
142         if(nWantSize <= 0 || NULL == pBuf)
143         {
144             return 0;
145         }
146 
147         int32_t nDataSize = ((m_nDataSize < nWantSize)?m_nDataSize : nWantSize);
148         if(nDataSize<=0)
149         {
150             return 0;
151         }
152        if(m_nReadIndex < m_nWriteIndex)
153         {
154             memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
155             m_nReadIndex += nDataSize;
156         }
157         else
158         {
159             int32_t nLeftDataSize = m_nBufSize - m_nReadIndex;
160             if(nLeftDataSize < nDataSize)
161             {
162                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nLeftDataSize);
163                 memcpy(pBuf+nLeftDataSize, &m_pBuf[0], nDataSize-nLeftDataSize);
164                 m_nReadIndex = nDataSize-nLeftDataSize;
165             }
166             else
167             {
168                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
169                 m_nReadIndex += nDataSize;
170             }
171         }
172         m_nDataSize -= nDataSize;
173         return nDataSize;
174     }
175 
176 
177     //读取数据但是不修改读索引
178     int32_t  PeekRead(uint8_t *pBuf, const int32_t nWantSize)
179     {
180         if(nWantSize <= 0 || pBuf == NULL)
181         {
182             return 0;
183    }
184 
185         int32_t  nDataSize = ((m_nDataSize < nWantSize) ? m_nDataSize : nWantSize);
186         if(m_nReadIndex < m_nWriteIndex)
187         {
188             memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
189         }
190         else if(m_nReadIndex == m_nWriteIndex)
191         {
192             return 0;
193         }
194         else
195         {
196             int32_t nLeftDataSize = m_nBufSize - m_nReadIndex;
197             if(nLeftDataSize < nDataSize)
198             {
199                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nLeftDataSize);
200                 memcpy(pBuf+nLeftDataSize, &m_pBuf[0], nDataSize-nLeftDataSize);
201             }
202             else
203             {
204                 memcpy(pBuf, &m_pBuf[m_nReadIndex], nDataSize);
205             }
206         }
207         return  nDataSize;
208     }
209    
210 };