开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
bytesrc.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：21k
源码类别：

生物技术

开发平台：

C/C++

bytesrc.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: bytesrc.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:39:53  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.33
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: bytesrc.cpp,v 1000.3 2004/06/01 19:39:53 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author: Eugene Vasilchenko
  36.  *
  37.  * File Description:
  38.  *   Implementation of CByteSource and CByteSourceReader
  39.  *   and their specializations'.
  40.  *
  41.  */
  43. #include <ncbi_pch.hpp>
  44. #include <corelib/ncbistd.hpp>
  45. #include <util/bytesrc.hpp>
  46. #include <util/util_exception.hpp>
  47. #include <util/stream_utils.hpp>
  48. #include <algorithm>
  51. BEGIN_NCBI_SCOPE
  54. typedef CFileSourceCollector::TFilePos TFilePos;
  55. typedef CFileSourceCollector::TFileOff TFileOff;
  57. /////////////////////////////////////////////////////////////////////////////
  58. // CByteSource
  59. /////////////////////////////////////////////////////////////////////////////
  61. CByteSource::CByteSource(void)
  62. {
  63. }
  66. CByteSource::~CByteSource(void)
  67. {
  68. }
  71. /////////////////////////////////////////////////////////////////////////////
  72. // CByteSourceReader
  73. /////////////////////////////////////////////////////////////////////////////
  75. CByteSourceReader::CByteSourceReader(void)
  76. {
  77. }
  80. CByteSourceReader::~CByteSourceReader(void)
  81. {
  82. }
  85. bool CByteSourceReader::EndOfData(void) const
  86. {
  87.     return true;
  88. }
  91. bool CByteSourceReader::Pushback(const char* /*data*/, size_t size)
  92. {
  93.     if ( size ) {
  94.         ERR_POST("CByteSourceReader::Pushback: "
  95.                  "cannot push back " << size << " bytes");
  96.         return false;
  97.     }
  98.     return true;
  99. }
  101. void CByteSourceReader::Seekg(size_t pos)
  102. {
  103.     NCBI_THROW(CUtilException,eWrongCommand,"CByteSourceReader::Seekg: unable to seek");
  104. }
  107. CRef<CSubSourceCollector>
  108. CByteSourceReader::SubSource(size_t /*prevent*/,
  109.                              CRef<CSubSourceCollector> parent)
  110. {
  111.     return CRef<CSubSourceCollector>(new CMemorySourceCollector(parent));
  112. }
  115. /////////////////////////////////////////////////////////////////////////////
  116. // CSubSourceCollector
  117. /////////////////////////////////////////////////////////////////////////////
  120. CSubSourceCollector::CSubSourceCollector(CRef<CSubSourceCollector> parent)
  121.     : m_ParentSubSource(parent)
  122. {
  123.     return;
  124. }
  127. CSubSourceCollector::~CSubSourceCollector(void)
  128. {
  129.     return;
  130. }
  133. void CSubSourceCollector::AddChunk(const char* buffer, size_t bufferLength)
  134. {
  135.     if ( !m_ParentSubSource.IsNull() ) {
  136.         m_ParentSubSource->AddChunk(buffer,bufferLength);
  137.     }
  138. }
  141. /////////////////////////////////////////////////////////////////////////////
  142. // CStreamByteSource
  143. /////////////////////////////////////////////////////////////////////////////
  145. /* Mac compiler doesn't like getting these flags as unsigned int (thiessen)
  146. static inline
  147. unsigned IFStreamFlags(bool binary)
  148. {
  149.     return binary ? (IOS_BASE::in | IOS_BASE::binary) : IOS_BASE::in;
  150. }
  151. */
  152. #define IFStreamFlags(isBinary) 
  153.   (isBinary? (IOS_BASE::in | IOS_BASE::binary): IOS_BASE::in)
  156. CStreamByteSource::CStreamByteSource(CNcbiIstream& in)
  157.     : m_Stream(&in)
  158. {
  159. }
  162. CStreamByteSource::~CStreamByteSource(void)
  163. {
  164. }
  167. CRef<CByteSourceReader> CStreamByteSource::Open(void)
  168. {
  169.     return CRef<CByteSourceReader>
  170.         (new CStreamByteSourceReader(this, m_Stream));
  171. }
  174. /////////////////////////////////////////////////////////////////////////////
  175. // CStreamByteSourceReader
  176. /////////////////////////////////////////////////////////////////////////////
  178. CStreamByteSourceReader::CStreamByteSourceReader(const CByteSource* source,
  179.                                                  CNcbiIstream* stream)
  180.     : m_Source(source), m_Stream(stream)
  181. {
  182. }
  185. CStreamByteSourceReader::~CStreamByteSourceReader(void)
  186. {
  187. }
  190. size_t CStreamByteSourceReader::Read(char* buffer, size_t bufferLength)
  191. {
  192.     return CStreamUtils::Readsome(*m_Stream, buffer, bufferLength);
  193. }
  196. bool CStreamByteSourceReader::EndOfData(void) const
  197. {
  198.     return m_Stream->eof();
  199. }
  202. bool CStreamByteSourceReader::Pushback(const char* data, size_t size)
  203. {
  204.     CStreamUtils::Pushback(*m_Stream, data, size);
  205.     return true;
  206. }
  208. void CStreamByteSourceReader::Seekg(size_t pos)
  209. {
  210.     m_Stream->seekg(pos);
  211. }
  213. /////////////////////////////////////////////////////////////////////////////
  214. // CIRByteSourceReader
  215. /////////////////////////////////////////////////////////////////////////////
  217. CIRByteSourceReader::CIRByteSourceReader(IReader* reader)
  218.     : m_Reader(reader), m_EOF(false)
  219. {
  220. }
  223. CIRByteSourceReader::~CIRByteSourceReader(void)
  224. {
  225. }
  228. size_t CIRByteSourceReader::Read(char* buffer, size_t bufferLength)
  229. {
  230.     size_t bytes_read;
  231.     m_Reader->Read(buffer, bufferLength, &bytes_read);
  232.     if ( bytes_read < bufferLength ) {
  233.         m_EOF = true;
  234.     }
  235.     return bytes_read;
  236. }
  239. bool CIRByteSourceReader::EndOfData(void) const
  240. {
  241.     return m_EOF;
  242. }
  245. /////////////////////////////////////////////////////////////////////////////
  246. // CFStreamByteSource
  247. /////////////////////////////////////////////////////////////////////////////
  249. CFStreamByteSource::CFStreamByteSource(CNcbiIstream& in)
  250.     : CStreamByteSource(in)
  251. {
  252. }
  255. CFStreamByteSource::CFStreamByteSource(const string& fileName, bool binary)
  256.     : CStreamByteSource(*new CNcbiIfstream(fileName.c_str(),
  257.                                            IFStreamFlags(binary)))
  258. {
  259.     if ( !*m_Stream ) {
  260.         NCBI_THROW(CUtilException,eNoInput,"file not found: " + fileName);
  261.     }
  262. }
  265. CFStreamByteSource::~CFStreamByteSource(void)
  266. {
  267.     delete m_Stream;
  268. }
  271. /////////////////////////////////////////////////////////////////////////////
  272. // CFileByteSource
  273. /////////////////////////////////////////////////////////////////////////////
  275. CFileByteSource::CFileByteSource(const string& fileName, bool binary)
  276.     : m_FileName(fileName), m_Binary(binary)
  277. {
  278.     return;
  279. }
  282. CFileByteSource::CFileByteSource(const CFileByteSource& file)
  283.     : m_FileName(file.m_FileName), m_Binary(file.m_Binary)
  284. {
  285.     return;
  286. }
  289. CFileByteSource::~CFileByteSource(void)
  290. {
  291. }
  294. CRef<CByteSourceReader> CFileByteSource::Open(void)
  295. {
  296.     return CRef<CByteSourceReader>(new CFileByteSourceReader(this));
  297. }
  300. /////////////////////////////////////////////////////////////////////////////
  301. // CSubFileByteSource
  302. /////////////////////////////////////////////////////////////////////////////
  304. CSubFileByteSource::CSubFileByteSource(const CFileByteSource& file,
  305.                                        TFilePos start, TFileOff length)
  306.     : CParent(file), m_Start(start), m_Length(length)
  307. {
  308.     return;
  309. }
  312. CSubFileByteSource::~CSubFileByteSource(void)
  313. {
  314. }
  317. CRef<CByteSourceReader> CSubFileByteSource::Open(void)
  318. {
  319.     return CRef<CByteSourceReader>
  320.         (new CSubFileByteSourceReader(this, m_Start, m_Length));
  321. }
  323. /////////////////////////////////////////////////////////////////////////////
  324. // CFileByteSourceReader
  325. /////////////////////////////////////////////////////////////////////////////
  327. CFileByteSourceReader::CFileByteSourceReader(const CFileByteSource* source)
  328.     : CStreamByteSourceReader(source, 0),
  329.       m_FileSource(source),
  330.       m_FStream(source->GetFileName().c_str(),
  331.                 IFStreamFlags(source->IsBinary()))
  332. {
  333.     if ( !m_FStream ) {
  334. //        THROW1_TRACE(runtime_error, "file not found: " +
  335. //                     source->GetFileName());
  336.         NCBI_THROW(CUtilException,eNoInput,
  337.                    "file not found: " +source->GetFileName());
  338.     }
  339.     m_Stream = &m_FStream;
  340. }
  343. CFileByteSourceReader::~CFileByteSourceReader(void)
  344. {
  345. }
  348. CRef<CSubSourceCollector> 
  349. CFileByteSourceReader::SubSource(size_t prepend, 
  350.                                  CRef<CSubSourceCollector> parent)
  351. {
  352.     return CRef<CSubSourceCollector>(new CFileSourceCollector(m_FileSource,
  353.                                     m_Stream->tellg() - TFileOff(prepend),
  354.                                     parent));
  355. }
  357. /////////////////////////////////////////////////////////////////////////////
  358. // CSubFileByteSourceReader
  359. /////////////////////////////////////////////////////////////////////////////
  361. CSubFileByteSourceReader::CSubFileByteSourceReader(const CFileByteSource* s,
  362.                                                    TFilePos start,
  363.                                                    TFileOff length)
  364.     : CParent(s), m_Length(length)
  365. {
  366.     m_Stream->seekg(start);
  367. }
  370. CSubFileByteSourceReader::~CSubFileByteSourceReader(void)
  371. {
  372. }
  375. size_t CSubFileByteSourceReader::Read(char* buffer, size_t bufferLength)
  376. {
  377.     if ( TFileOff(bufferLength) > m_Length ) {
  378.         bufferLength = size_t(m_Length);
  379.     }
  380.     size_t count = CParent::Read(buffer, bufferLength);
  381.     m_Length -= TFileOff(count);
  382.     return count;
  383. }
  386. bool CSubFileByteSourceReader::EndOfData(void) const
  387. {
  388.     return m_Length == 0;
  389. }
  392. /////////////////////////////////////////////////////////////////////////////
  393. // CFileSourceCollector
  394. /////////////////////////////////////////////////////////////////////////////
  397. CFileSourceCollector::CFileSourceCollector(CConstRef<CFileByteSource> s,
  398.                                            TFilePos start,
  399.                                            CRef<CSubSourceCollector> parent)
  400.     : CSubSourceCollector(parent),
  401.       m_FileSource(s),
  402.       m_Start(start),
  403.       m_Length(0)
  404. {
  405. }
  408. CFileSourceCollector::~CFileSourceCollector(void)
  409. {
  410. }
  413. void CFileSourceCollector::AddChunk(const char* buffer,
  414.                                     size_t bufferLength)
  415. {
  416.     CSubSourceCollector::AddChunk(buffer, bufferLength);
  417.     m_Length += TFileOff(bufferLength);
  418. }
  421. CRef<CByteSource> CFileSourceCollector::GetSource(void)
  422. {
  423.     return CRef<CByteSource>(new CSubFileByteSource(*m_FileSource,
  424.                                   m_Start, m_Length));
  425. }
  428. /////////////////////////////////////////////////////////////////////////////
  429. // CMemoryChunk
  430. /////////////////////////////////////////////////////////////////////////////
  432. CMemoryChunk::CMemoryChunk(const char* data, size_t dataSize,
  433.                            CRef<CMemoryChunk> prevChunk)
  434.     : m_Data(new char[dataSize]),
  435.       m_DataSize(dataSize)
  436. {
  437.     memcpy(m_Data, data, dataSize);
  438.     if ( prevChunk ) {
  439.         prevChunk->m_NextChunk = this;
  440.     }
  441.     prevChunk = this;
  442. }
  445. CMemoryChunk::~CMemoryChunk(void)
  446. {
  447.     delete m_Data;
  448. }
  451. /////////////////////////////////////////////////////////////////////////////
  452. // CMemoryByteSource
  453. /////////////////////////////////////////////////////////////////////////////
  455. CMemoryByteSource::CMemoryByteSource(CConstRef<CMemoryChunk> bytes)
  456.     : m_Bytes(bytes)
  457. {
  458. }
  461. CMemoryByteSource::~CMemoryByteSource(void)
  462. {
  463. }
  466. CRef<CByteSourceReader> CMemoryByteSource::Open(void)
  467. {
  468.     return CRef<CByteSourceReader>(new CMemoryByteSourceReader(m_Bytes));
  469. }
  472. /////////////////////////////////////////////////////////////////////////////
  473. // CMemoryByteSourceReader
  474. /////////////////////////////////////////////////////////////////////////////
  477. CMemoryByteSourceReader::CMemoryByteSourceReader(CConstRef<CMemoryChunk> bytes)
  478.     : m_CurrentChunk(bytes), m_CurrentChunkOffset(0)
  479. {
  480. }
  483. CMemoryByteSourceReader::~CMemoryByteSourceReader(void)
  484. {
  485. }
  488. size_t CMemoryByteSourceReader::GetCurrentChunkAvailable(void) const
  489. {
  490.     return m_CurrentChunk->GetDataSize() - m_CurrentChunkOffset;
  491. }
  494. size_t CMemoryByteSourceReader::Read(char* buffer, size_t bufferLength)
  495. {
  496.     while ( m_CurrentChunk ) {
  497.         size_t avail = GetCurrentChunkAvailable();
  498.         if ( avail == 0 ) {
  499.             // End of current chunk
  500.             CConstRef<CMemoryChunk> rest = m_CurrentChunk->GetNextChunk();
  501.             m_CurrentChunk = rest;
  502.             m_CurrentChunkOffset = 0;
  503.         }
  504.         else {
  505.             size_t c = min(bufferLength, avail);
  506.             memcpy(buffer, m_CurrentChunk->GetData(m_CurrentChunkOffset), c);
  507.             m_CurrentChunkOffset += c;
  508.             return c;
  509.         }
  510.     }
  511.     return 0;
  512. }
  515. bool CMemoryByteSourceReader::EndOfData(void) const
  516. {
  517.     return !m_CurrentChunk;
  518. }
  521. /////////////////////////////////////////////////////////////////////////////
  522. // CMemorySourceCollector
  523. /////////////////////////////////////////////////////////////////////////////
  525. CMemorySourceCollector::CMemorySourceCollector(CRef<CSubSourceCollector>
  526.                                                parent)
  527.     : CSubSourceCollector(parent)
  528. {
  529. }
  532. CMemorySourceCollector::~CMemorySourceCollector(void)
  533. {
  534. }
  537. void CMemorySourceCollector::AddChunk(const char* buffer,
  538.                                       size_t bufferLength)
  539. {
  540.     CSubSourceCollector::AddChunk(buffer, bufferLength);
  541.     m_LastChunk = new CMemoryChunk(buffer, bufferLength, m_LastChunk);
  542.     if ( !m_FirstChunk ) {
  543.         m_FirstChunk = m_LastChunk;
  544.     }
  545. }
  548. CRef<CByteSource> CMemorySourceCollector::GetSource(void)
  549. {
  550.     return CRef<CByteSource>(new CMemoryByteSource(m_FirstChunk));
  551. }
  554. /////////////////////////////////////////////////////////////////////////////
  555. // CWriterSourceCollector
  556. /////////////////////////////////////////////////////////////////////////////
  558. CWriterSourceCollector::CWriterSourceCollector(IWriter*    writer, 
  559.                                                EOwnership  own, 
  560.                                        CRef<CSubSourceCollector>  parent)
  561.     : CSubSourceCollector(parent),
  562.       m_Writer(writer),
  563.       m_Own(own)
  564. {
  565.     return;
  566. }
  569. CWriterSourceCollector::~CWriterSourceCollector()
  570. {
  571.     if ( m_Own ) {
  572.         delete m_Writer;
  573.     }
  574. }
  577. void CWriterSourceCollector::SetWriter(IWriter*   writer, 
  578.                                        EOwnership own)
  579. {
  580.     if ( m_Own ) {
  581.         delete m_Writer;
  582.     }
  583.     m_Writer = writer;
  584.     m_Own = own;    
  585. }
  588. void CWriterSourceCollector::AddChunk(const char* buffer, size_t bufferLength)
  589. {
  590.     size_t written;
  591.     m_Writer->Write(buffer, bufferLength, &written);
  592. }
  595. CRef<CByteSource> CWriterSourceCollector::GetSource(void)
  596. {
  597.     // Return NULL byte source, this happens because we cannot derive
  598.     // any readers from IWriter (one way interface)
  599.     return CRef<CByteSource>();
  600. }
  603. /////////////////////////////////////////////////////////////////////////////
  604. // CWriterByteSourceReader
  605. /////////////////////////////////////////////////////////////////////////////
  607. CWriterByteSourceReader::CWriterByteSourceReader(CNcbiIstream* stream,
  608.                                                  IWriter* writer)
  609.     : CStreamByteSourceReader(0 /* CByteSource* */, stream),
  610.       m_Writer(writer)
  611. {
  612.     _ASSERT(writer);
  613. }
  616. CWriterByteSourceReader::~CWriterByteSourceReader(void)
  617. {
  618. }
  621. CRef<CSubSourceCollector> 
  622. CWriterByteSourceReader::SubSource(size_t /*prepend*/,
  623.                                    CRef<CSubSourceCollector> parent)
  624. {
  625.     return 
  626.         CRef<CSubSourceCollector>(
  627.             new CWriterSourceCollector(m_Writer, eNoOwnership, parent));
  628. }
  631. /////////////////////////////////////////////////////////////////////////////
  632. // CWriterCopyByteSourceReader
  633. /////////////////////////////////////////////////////////////////////////////
  635. CWriterCopyByteSourceReader::CWriterCopyByteSourceReader(CByteSourceReader* reader, IWriter* writer)
  636.     : m_Reader(reader),
  637.       m_Writer(writer)
  638. {
  639.     _ASSERT(reader);
  640.     _ASSERT(writer);
  641. }
  644. CWriterCopyByteSourceReader::~CWriterCopyByteSourceReader(void)
  645. {
  646. }
  649. size_t CWriterCopyByteSourceReader::Read(char* buffer, size_t bufferLength)
  650. {
  651.     return m_Reader->Read(buffer, bufferLength);
  652. }
  655. bool CWriterCopyByteSourceReader::EndOfData(void) const
  656. {
  657.     return m_Reader->EndOfData();
  658. }
  661. CRef<CSubSourceCollector>
  662. CWriterCopyByteSourceReader::SubSource(size_t /*prepend*/,
  663.                                        CRef<CSubSourceCollector> parent)
  664. {
  665.     return 
  666.         CRef<CSubSourceCollector>(
  667.             new CWriterSourceCollector(m_Writer, eNoOwnership, parent));
  668. }
  671. END_NCBI_SCOPE
  674. /*
  675.  * ===========================================================================
  676.  * $Log: bytesrc.cpp,v $
  677.  * Revision 1000.3  2004/06/01 19:39:53  gouriano
  678.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.33
  679.  *
  680.  * Revision 1.33  2004/05/17 21:06:02  gorelenk
  681.  * Added include of PCH ncbi_pch.hpp
  682.  *
  683.  * Revision 1.32  2003/12/31 20:51:33  gouriano
  684.  * added possibility to seek (when possible) in CByteSourceReader
  685.  *
  686.  * Revision 1.31  2003/11/19 15:40:09  vasilche
  687.  * Added possibility to pushback data to CByteSourceReader.
  688.  *
  689.  * Revision 1.30  2003/10/20 21:18:18  ivanov
  690.  * Get rid of compilation warning
  691.  *
  692.  * Revision 1.29  2003/10/14 18:28:33  vasilche
  693.  * Added full set of explicit constructors/destructors to all readers and sources.
  694.  * Added CWriterCopyByteSourceReader for copying data from another reader object.
  695.  *
  696.  * Revision 1.28  2003/10/01 21:14:55  ivanov
  697.  * Formal code rearrangement
  698.  *
  699.  * Revision 1.27  2003/10/01 19:27:57  kuznets
  700.  * Fixed compilation bug with CIRByteSourceReader::m_EOF
  701.  *
  702.  * Revision 1.26  2003/10/01 18:45:33  kuznets
  703.  * +CIRByteSourceReader
  704.  *
  705.  * Revision 1.25  2003/09/30 20:37:54  kuznets
  706.  * Class names clean up (Removed I from CI prefix for classes based in
  707.  * interfaces)
  708.  *
  709.  * Revision 1.24  2003/09/30 20:24:03  kuznets
  710.  * +CIWriterByteSourceReader
  711.  *
  712.  * Revision 1.23  2003/09/30 20:08:02  kuznets
  713.  * +CStreamRedirectByteSourceReader implementation
  714.  *
  715.  * Revision 1.22  2003/09/25 16:38:03  kuznets
  716.  * + IWriter based sub source collector
  717.  *
  718.  * Revision 1.21  2003/09/25 13:59:40  ucko
  719.  * Pass C(Const)Ref by value, not reference!
  720.  *
  721.  * Revision 1.20  2003/09/25 12:47:36  kuznets
  722.  * Added subsource chaining
  723.  *
  724.  * Revision 1.19  2003/02/26 21:32:00  gouriano
  725.  * modify C++ exceptions thrown by this library
  726.  *
  727.  * Revision 1.18  2002/11/27 21:08:52  lavr
  728.  * Take advantage of CStreamUtils::Readsome() in CStreamByteSource::Read()
  729.  *
  730.  * Revision 1.17  2002/11/04 21:29:22  grichenk
  731.  * Fixed usage of const CRef<> and CRef<> constructor
  732.  *
  733.  * Revision 1.16  2002/01/17 17:57:14  vakatov
  734.  * [GCC > 3.0]  CStreamByteSourceReader::Read() -- use "readsome()", thus
  735.  * avoid blocking on timeout at EOF for non-blocking input stream.
  736.  *
  737.  * Revision 1.15  2001/08/15 18:43:34  lavr
  738.  * FIXED CStreamByteSourceReader::Read:
  739.  * ios::clear() has to have no arguments in order to clear EOF state.
  740.  *
  741.  * Revision 1.14  2001/05/30 19:55:35  grichenk
  742.  * Fixed one more non-blocking stream reading bug, added comments
  743.  *
  744.  * Revision 1.13  2001/05/29 19:35:23  grichenk
  745.  * Fixed non-blocking stream reading for GCC
  746.  *
  747.  * Revision 1.12  2001/05/17 15:07:15  lavr
  748.  * Typos corrected
  749.  *
  750.  * Revision 1.11  2001/05/16 17:55:40  grichenk
  751.  * Redesigned support for non-blocking stream read operations
  752.  *
  753.  * Revision 1.10  2001/05/11 20:41:19  grichenk
  754.  * Added support for non-blocking stream reading
  755.  *
  756.  * Revision 1.9  2001/05/11 14:00:21  grichenk
  757.  * CStreamByteSourceReader::Read() -- use readsome() instead of read()
  758.  *
  759.  * Revision 1.8  2001/01/05 20:09:05  vasilche
  760.  * Added util directory for various algorithms and utility classes.
  761.  *
  762.  * Revision 1.7  2000/11/01 20:38:37  vasilche
  763.  * Removed ECanDelete enum and related constructors.
  764.  *
  765.  * Revision 1.6  2000/09/01 13:16:14  vasilche
  766.  * Implemented class/container/choice iterators.
  767.  * Implemented CObjectStreamCopier for copying data without loading into memory
  768.  *
  769.  * Revision 1.5  2000/07/03 18:42:42  vasilche
  770.  * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  771.  * Reduced header dependency.
  772.  *
  773.  * Revision 1.4  2000/06/22 16:13:48  thiessen
  774.  * change IFStreamFlags to macro
  775.  *
  776.  * Revision 1.3  2000/05/03 14:38:13  vasilche
  777.  * SERIAL: added support for delayed reading to generated classes.
  778.  * DATATOOL: added code generation for delayed reading.
  779.  *
  780.  * Revision 1.2  2000/04/28 19:14:37  vasilche
  781.  * Fixed stream position and offset typedefs.
  782.  *
  783.  * Revision 1.1  2000/04/28 16:58:11  vasilche
  784.  * Added classes CByteSource and CByteSourceReader for generic reading.
  785.  * Added delayed reading of choice variants.
  786.  *
  787.  * ===========================================================================
  788.  */