环行缓冲区的实现(V0.2,C++源码)

1. //---------------------------------------------------------------------------
2. // 模块:          环形缓冲区类 TFengRingBuf
3. // 版本号:        V0.2
4. // 编写人:        Twicave([e-mail])
5. //
6. // 简要说明:      实现了环形缓冲区(频繁的读取写入操作时,无需进行缓冲区的重整)
7. //                主要用于通讯类的操作.代码用C++ template编写,可直接以源代码
8. //                的方式包含进工程中使用.BC6.0测试通过.不含BC Local代码,可用
9. //                于其他编译环境.
10. // 备注：
11. //    Aug05,2008  初步完成。支持接近手工编码的方案。需要解释一下"只读"的概念.
12. //                在尝试对环形缓冲区进行写入操作时，因为Context中的函数均是对
13. //                标准缓冲区进行操作的.此时涉及缓冲区的转换操作.这里采用的方案
14. //                是先用WriteBuf()取出一个缓冲区,这个缓冲区可能就位于原始缓冲
15. //                区内,也可能是因为接近边界处而生成的一个临时缓冲区.因为此时
16. //                可能已经对环形缓冲区的内容进行写入操作(在相当高的概率下),所
17. //                以后续的写入操作必须延迟(写入操作涉及Resize和Push).对于缓冲
18. //                区的察看,有类似的情形.一旦用户通过ReadBuf()注册了对缓冲区的
19. //                察看操作,则后续的对读指针的修改也必须挂起.否则可能导致正在读
20. //                取的内容被后续写入操作污染.
21. //                目前尚需要改进的地方有循环概念的实现.(目前一旦缓冲区满就不再
22. //                接受最新的输入了.)不过环形缓冲区 != 循环缓冲区.对不对?
23. //
24. //    Aug04,2008  发现最重要的工作是如何替换标准的缓冲区。性能必须要接近标准缓
25. //                冲区，否则就失去意义了。
26. //
27. //    Aug02,2008  开始编码
28. //---------------------------------------------------------------------------
29. #ifndef FengRingBufH
30. #define FengRingBufH
31. #include <ctype.h> //for size_t定义
32. #include <assert.h> //for assert()
33. //---------------------------------------------------------------------------
34. template<class TYPE = unsigned char>
35. class TFengRingBuf
36. {
37. public:
38.    //构造函数
39.                      TFengRingBuf(size_t size = 0);
40.    //析构函数
41.    virtual           ~TFengRingBuf(void);
43.    //取容量
44.    inline size_t     Size(void);
45.    //取长度
46.    size_t            Len(void);
47.    //取元素
48.    TYPE              operator[](size_t pos);
49.    //归零
50.    inline void       Reset(void);
51.    //重设缓冲区尺寸
52.    void              ReSize(size_t size);
54.    //导入数据
55.    size_t            Push(TYPE *buf, size_t len);
56.    //导入数据,用于缓冲区之间转移 (buf=>本地,buf相关指针不变)
57.    size_t            Push(TFengRingBuf<TYPE>& buf, size_t len);
59.    //缓冲区转换(用户负责对返回的数组析构)
60.    TYPE*             Get(size_t& len);
61.    //读取数据
62.    size_t            Get(TYPE *buf, size_t len);
64.    //取出数据(用户负责对返回的数组析构)
65.    TYPE*             Pop(size_t& len);
66.    //取出数据
67.    size_t            Pop(TYPE *buf, size_t len);
68.    //导出数据，用于缓冲区之间转移 (本地=>buf,本地相关指针改变)
69.    size_t            Pop(TFengRingBuf<TYPE>& buf, size_t& len);
71.    //导出写入缓冲区（本操作执行以后无法对缓冲区进行写入操作）
72.    TYPE*             WriteBuf(size_t size = 0);
73.    //写入缓冲区尺寸
74.    inline size_t     SizeOfWriteBuf(void);
75.    //写入缓冲区长度
76.    inline size_t&    LenOfWriteBuf(void);
77.    //导出的写入缓冲区提交（提交后恢复对缓冲区进行写入操作响应）
78.    size_t            CommitWriteBuf(size_t len);
80.    //导出读取缓冲区（本操作执行以后不可对读指针进行移动,实际的缓冲区尺寸可能不足size,请查询SizeOfReadBuf()）
81.    TYPE*             ReadBuf(size_t size = 0);
82.    //读取缓冲区尺寸
83.    inline size_t     SizeOfReadBuf(void);
84.    //读取缓冲区位置指针
85.    inline size_t&    PosOfReadBuf(void);
86.    //导出的读取缓冲区提交（提交后恢复对对读指针移动的响应）
87.    size_t            CommitReadBuf(size_t len);
89. private:
90.    TYPE                    *_buf;            //缓冲区指针
91.    size_t                  _pRead;           //读指针
92.    size_t                  _pWrite;          //写指针
93.    size_t                  _size;            //尺寸
95.    TYPE                    *_writeBuf;       //写入缓冲区首地址
96.    size_t                  _sizeWriteBuf;    //写入缓冲区尺寸
97.    size_t                  _lenWriteBuf;     //写入缓冲区位置指针
98.    bool                    _isWriteBufTemp;  //写入缓冲区是否为临时缓冲区
100.    TYPE                    *_readBuf;        //读取缓冲区首地址
101.    size_t                  _sizeReadBuf;     //读取缓冲区尺寸
102.    size_t                  _posReadBuf;      //读取缓冲区读取指针
103.    bool                    _isReadBufTemp;   //读取缓冲区是否为临时缓冲区
105. };
107. template<class TYPE>
108. TFengRingBuf<TYPE>::TFengRingBuf(size_t size)
109. {
110.    _pRead = _pWrite = 0;
111.    _buf = new TYPE[size + 1];
112.    assert(NULL != _buf);
113.    _size = size;
115.    _writeBuf = NULL;
116.    _sizeWriteBuf = 0;
117.    _lenWriteBuf = 0;
118.    _isWriteBufTemp = false;
120.    _readBuf = NULL;
121.    _sizeReadBuf = 0;
122.    _posReadBuf = 0;
123.    _isReadBufTemp = false;
124. }
126. template<class TYPE>
127. TFengRingBuf<TYPE>::~TFengRingBuf(void)
128. {
129.    if(0 != SizeOfWriteBuf()) CommitWriteBuf(0); //writeBuf只读处理
130.    if(0 != SizeOfReadBuf()) CommitReadBuf(0); //readBuf只读处理
131.    delete[] _buf;
132. }
134. template<class TYPE>
135. size_t TFengRingBuf<TYPE>::Size(void)
136. {
137.    return _size;
138. }
140. template<class TYPE>
141. size_t TFengRingBuf<TYPE>::Len(void)
142. {
143.    return ((_pWrite+Size()+1) - _pRead) % (Size()+1);
144. }
146. template<class TYPE>
147. TYPE TFengRingBuf<TYPE>::operator[](size_t pos)
148. {
149.    return _buf[(_pRead+pos)%(Size()+1)];
150. }
152. template<class TYPE>
153. void TFengRingBuf<TYPE>::Reset(void)
154. {
155.    _pRead = _pWrite = 0;
156. }
158. template<class TYPE>
159. void TFengRingBuf<TYPE>::ReSize(size_t size)
160. {
161.    if(0 != SizeOfWriteBuf()) return; //writeBuf只读处理
163.    //取出所有数据，并删除原始数组
164.    size_t len;
165.    TYPE *buf = Get(len);
166.    delete[] _buf;
167.    Reset();
169.    _buf = new TYPE[size + 1];
170.    _size = size;
171.    assert(NULL != _buf);
172.    Push(buf, len);
173.    delete[] buf;
174. }
177. template<class TYPE>
178. size_t TFengRingBuf<TYPE>::Push(TYPE *buf, size_t len)
179. {
180.    if(0 != SizeOfWriteBuf()) return 0; //writeBuf只读处理
182.    //传入数据溢出处理(仅移入尾部)
183.    if(len > Size() - Len())
184.    {
185.       size_t oldLen = len;
186.       len = Size() - Len();
187.       buf += oldLen - len;
188.    }
189.    if(0 == len) return 0;
191.    //尝试分两步拷贝
192.    size_t tryMove = (0 == _pRead) ?
193.                         Size()+1-_pWrite-1 : Size()+1-_pWrite;
194.    if( tryMove >= len)
195.    {
196.       memcpy(&_buf[_pWrite], buf, sizeof(TYPE)*len);
197.    }
198.    else
199.    {
200.       memcpy(&_buf[_pWrite], buf, sizeof(TYPE)*tryMove);
201.       memcpy(&_buf[0], &buf[tryMove], sizeof(TYPE)*(len - tryMove));
202.    }
204.    //指针移动
205.    _pWrite += len;
206.    _pWrite %= Size() + 1;
208.    return len;
209. }
211. template<class TYPE>
212. size_t TFengRingBuf<TYPE>::Push(TFengRingBuf<TYPE>& buf, size_t len)
213. {
214.    if(0 != SizeOfWriteBuf()) return 0; //writeBuf只读处理
216.    size_t ret, tempLen;
217.    tempLen = len > buf.Len() ? buf.Len() : len;
218.    TYPE *tempBuf = new TYPE[tempLen];
220.    tempLen = buf.Get(tempBuf, tempLen);
221.    ret = Push(tempBuf, tempLen);
222.    delete[] tempBuf;
223.    return ret;
224. }
226. template<class TYPE>
227. TYPE * TFengRingBuf<TYPE>::Get(size_t& len)
228. {
229.    TYPE *buf(NULL);
230.    len = Len();
231.    if(0 != len)
232.    {
233.       buf = new TYPE[Len()];
234.       Get(buf, Len());
235.    }
236.    return buf;
237. }
239. template<class TYPE>
240. size_t TFengRingBuf<TYPE>::Get(TYPE *buf, size_t len)
241. {
242.    //传入参数合法化
243.    if(len > Len())
244.    {
245.       len = Len();
246.    }
248.    //尝试分两步拷贝
249.    size_t tryMove = (_pWrite > _pRead) ?
250.       _pWrite - _pRead : (Size()+1 - _pRead);
251.    if(len <= tryMove)
252.    {
253.       memcpy(buf, &_buf[_pRead], len);
254.    }
255.    else
256.    {
257.       memcpy(&buf[0], &_buf[_pRead], tryMove);
258.       memcpy(&buf[tryMove], &_buf[0], len-tryMove);
259.    }
261.    return len;
262. }
264. template<class TYPE>
265. size_t TFengRingBuf<TYPE>::Pop(TYPE *buf, size_t len)
266. {
267.    if(0 != SizeOfReadBuf()) return 0; //readBuf只读处理
269.    len = Get(buf, len);
271.    _pRead += len;
272.    _pRead %= Size() + 1;
274.    return len;
275. }
277. template<class TYPE>
278. TYPE * TFengRingBuf<TYPE>::Pop(size_t& len)
279. {
280.    len = 0;
281.    if(0 != SizeOfReadBuf()) return NULL; //readBuf只读处理
283.    TYPE *buf = Get(len);
285.    _pRead += len;
286.    _pRead %= Size() + 1;
288.    return buf;
289. }
291. template<class TYPE>
292. size_t TFengRingBuf<TYPE>::Pop(TFengRingBuf<TYPE>& buf, size_t& len)
293. {
294.    if(0 != SizeOfReadBuf()) return 0; //readBuf只读处理
296.    if(len > this->Len())
297.    {
298.       len = this->Len();
299.    }
300.    size_t ret = buf.Push(*this, len);
302.    _pRead += len;
303.    _pRead %= Size() + 1;
305.    return ret;
306. }
308. template<class TYPE>
309. TYPE* TFengRingBuf<TYPE>::WriteBuf(size_t size)
310. {
311.    if(0 == size) return _writeBuf;
312.    if(0 != _sizeWriteBuf && 0 != size) return NULL; //writeBuf仅可取出一次，不支持多重导出
314.    _sizeWriteBuf = size;
315.    _lenWriteBuf = 0;
317.    if(Size()+1 - _pWrite >= size)
318.    {
319.       _writeBuf = &_buf[_pWrite];
320.       _isWriteBufTemp = false;
321.    }
322.    else
323.    {
324.       _writeBuf = new TYPE[size];
325.       assert(NULL != _writeBuf);
326.       _isWriteBufTemp = true;
327.    }
328.    return _writeBuf;
329. }
331. template<class TYPE>
332. size_t TFengRingBuf<TYPE>::SizeOfWriteBuf(void)
333. {
334.    return _sizeWriteBuf;
335. }
337. template<class TYPE>
338. size_t& TFengRingBuf<TYPE>::LenOfWriteBuf(void)
339. {
340.    return _lenWriteBuf;
341. }
343. template<class TYPE>
344. size_t TFengRingBuf<TYPE>::CommitWriteBuf(size_t len)
345. {
346.    if(0 == _sizeWriteBuf) return 0;
347.    if(len > _sizeWriteBuf) len = _sizeWriteBuf; //防止越界访问
349.    TYPE *pOuterBuf = _writeBuf;
350.    _writeBuf = NULL;
351.    _sizeWriteBuf = 0; //首先脱离outerBuf状态，否则无法写入
353.    if(_isWriteBufTemp)
354.    {
355.       len = Push(pOuterBuf, len);
356.       delete[] pOuterBuf;
357.       _isWriteBufTemp = false;
358.    }
359.    else
360.    {
361.       _pWrite += len; //无需处理指针回环
362.    }
363.    _lenWriteBuf = 0;
365.    return len;
366. }
368. template<class TYPE>
369. TYPE* TFengRingBuf<TYPE>::ReadBuf(size_t size)
370. {
371.    if(size > Len()) size = Len(); //防止越界访问
372.    if(0 == size) return _readBuf; //注意与上条语句的顺序
373.    if(0 != _sizeReadBuf && 0 != size) return NULL; //ReadBuf仅可取出一次，不支持多重导出
375.    if(Size()+1 - _pRead >= size)
376.    {
377.       _readBuf = &_buf[_pRead];
378.       _isReadBufTemp = false;
379.    }
380.    else
381.    {
382.       _readBuf = new TYPE[size];
383.       assert(NULL != _readBuf);
384.       Get(_readBuf, size);
385.       _isReadBufTemp = true;
386.    }
387.    _sizeReadBuf = size;
388.    _posReadBuf = 0;
390.    return _readBuf;
391. }
393. template<class TYPE>
394. size_t TFengRingBuf<TYPE>::SizeOfReadBuf(void)
395. {
396.    return _sizeReadBuf;
397. }
399. template<class TYPE>
400. size_t& TFengRingBuf<TYPE>::PosOfReadBuf(void)
401. {
402.    return _posReadBuf;
403. }
405. template<class TYPE>
406. size_t TFengRingBuf<TYPE>::CommitReadBuf(size_t len)
407. {
408.    if(len > Len()) len = Len(); //防止越界访问
410.    _pRead += len;
411.    _pRead %= Size() + 1;
413.    if(0 == _sizeReadBuf) return 0; //对于普通的读指针移动已经执行完毕
415.    if(_isReadBufTemp)
416.    {
417.       delete[] _readBuf;
418.       _isReadBufTemp = false;
419.    }
420.    _posReadBuf = 0;
421.    _sizeReadBuf = 0;
422.    _readBuf = NULL;
424.    return len;
425. }
426. #endif