bufio.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:5k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _BUFIO_H_
  36. #define _BUFIO_H_
  37. #include <string.h>
  38. #include <errno.h>
  39. #include "bio.h"
  40. #include "fio.h"
  41. #include "buffer.h"
  42. #include "hxassert.h"
  43. class Buffer_IO: public IO 
  44. {
  45. public:
  46. Buffer_IO(Buffer* buffer, INT32 flags);
  47. ~Buffer_IO();
  48.     virtual INT32 read(void* buf, INT32 size) = 0;
  49.     INT32 write(const void* buf, INT32 size);
  50.     virtual off_t seek(off_t new_off, INT32 whence) = 0;
  51.     virtual INT32 flush() = 0;
  52.     INT32 close() { return 0; };
  53.     Buffer* buf;
  54.     INT32 flags();
  55.     INT32 error();
  56.     virtual off_t file_size();
  57. protected:
  58.     INT32 _flags;
  59.     INT32 err;
  60. };
  61. class PipeBuf_IO : public Buffer_IO 
  62. {
  63. public:
  64. PipeBuf_IO();
  65. ~PipeBuf_IO();
  66.     INT32 read(void* buf, INT32 size);
  67.     off_t seek(off_t new_off, INT32 whence);
  68.     INT32 flush();
  69. };
  70. class FileBuf_IO : public Buffer_IO 
  71. {
  72. public:
  73. FileBuf_IO();
  74. FileBuf_IO(GrowBuffer* buffer, INT32 o_flags = O_RDWR);
  75. ~FileBuf_IO();
  76.     INT32 read(void* buf, INT32 size);
  77.     off_t seek(off_t new_off, INT32 whence);
  78.     INT32 flush();
  79. private:
  80.     off_t offset;
  81. };
  82. inline
  83. Buffer_IO::Buffer_IO(Buffer* buffer, INT32 o_flags) 
  84. {
  85.     buf = buffer;
  86.     _flags = o_flags;
  87. }
  88. inline
  89. Buffer_IO::~Buffer_IO() 
  90. {
  91.     if (buf->refcount == 0)
  92. delete buf;
  93. }
  94. inline INT32
  95. Buffer_IO::flags()
  96. {
  97.     return _flags;
  98. }
  99. inline INT32
  100. Buffer_IO::error()
  101. {
  102.     return err;
  103. }
  104. inline INT32
  105. Buffer_IO::write(const void* b, INT32 size) 
  106. {
  107.     buf->ensure_space(size);
  108.     memcpy(buf->space, b, size); /* Flawfinder: ignore */
  109.     buf->space += size;
  110.     return size;
  111. }
  112. inline off_t
  113. Buffer_IO::file_size()
  114. {
  115.     ASSERT(1);
  116.     return -1;
  117. }
  118. inline
  119. PipeBuf_IO::PipeBuf_IO() 
  120.     :
  121.     Buffer_IO(new WrapBuffer(), O_RDWR)
  122. {
  123.     buf->init(1024);
  124. }
  125. inline
  126. PipeBuf_IO::~PipeBuf_IO() 
  127. {
  128.     ASSERT(buf->refcount == 0);
  129. }
  130. inline INT32
  131. PipeBuf_IO::read(void* b, INT32 size) 
  132. {
  133.     INT32 count = buf->count();
  134.     if (count < size)
  135.        size = count;
  136.     memcpy(b, buf->data, size); /* Flawfinder: ignore */
  137.     buf->data += size;
  138.     return size;
  139. }
  140. inline off_t
  141. PipeBuf_IO::seek(off_t new_off, INT32 whence) 
  142. {
  143.     return (off_t)-1;
  144. }
  145. inline INT32
  146. PipeBuf_IO::flush() 
  147. {
  148.     buf->data = buf->space = buf->base;
  149.     return 0;
  150. }
  151. inline
  152. FileBuf_IO::FileBuf_IO() 
  153.     :
  154.     Buffer_IO(new GrowBuffer(), O_RDWR)
  155. {
  156.     buf->init(1024);
  157. }
  158. inline
  159. FileBuf_IO::FileBuf_IO(GrowBuffer* buffer, INT32 o_flags) 
  160.     :
  161.     Buffer_IO(buffer, o_flags)
  162. {
  163.     ASSERT(buf);
  164.     buf->refcount++;
  165.     offset = 0;
  166. }
  167. inline
  168. FileBuf_IO::~FileBuf_IO() 
  169. {
  170.     buf->refcount--;
  171. }
  172. inline INT32
  173. FileBuf_IO::read(void* b, INT32 size) 
  174. {
  175.     INT32 count = buf->count() - offset;
  176.     if (count < size)
  177.        size = count;
  178.     memcpy(b, buf->data + offset, size); /* Flawfinder: ignore */
  179.     offset += size;
  180.     return size;
  181. }
  182. inline off_t
  183. FileBuf_IO::seek(off_t new_off, INT32 whence) 
  184. {
  185.     /*
  186.      * XXX...this seek is for read only buffers. Seeking for write buffers
  187.      *       would require using offset for both reading and writing
  188.      */
  189.     ASSERT(_flags == O_RDONLY);
  190.     switch (whence)
  191.     {
  192. case SEEK_SET:
  193.     break;
  194. case SEEK_CUR:
  195.     new_off += offset;
  196.     break;
  197. case SEEK_END:
  198.     new_off = buf->used();
  199.     break;
  200. default:
  201.     err = EINVAL;
  202.     return 0;
  203.     }
  204.     Byte* b = buf->base + new_off;
  205.     /*
  206.      * It is not possible to seek past the end of data
  207.      */
  208.     if (b > buf->space)
  209. return -1;
  210.     offset = new_off;
  211.     return 0;
  212. }
  213. inline INT32
  214. FileBuf_IO::flush() 
  215. {
  216.     /*
  217.      * Does not exist for FileBuf_IO
  218.      */
  219.     return -1;
  220. }
  221. #endif/*_BUFIO_H_*/