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

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

生物技术

开发平台：

C/C++

stream_utils.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: stream_utils.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:40:35  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.42
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: stream_utils.cpp,v 1000.4 2004/06/01 19:40:35 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:  Anton Lavrentiev, Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   Stream utilities:
  39.  *   1. Push an arbitrary block of data back to a C++ input stream.
  40.  *   2. Non-blocking read.
  41.  *
  42.  */
  44. #include <ncbi_pch.hpp>
  45. #include <corelib/ncbistd.hpp>
  46. #include <util/util_exception.hpp>
  47. #include <util/stream_utils.hpp>
  48. #include <string.h>
  51. #ifdef NCBI_COMPILER_MIPSPRO
  52. #  define CPushback_StreambufBase CMIPSPRO_ReadsomeTolerantStreambuf
  53. #else
  54. #  define CPushback_StreambufBase CNcbiStreambuf
  55. #endif //NCBI_COMPILER_MIPSPRO
  57. #ifdef HAVE_GOOD_IOS_CALLBACKS
  58. #  undef  HAVE_GOOD_IOS_CALLBACKS
  59. #endif
  60. #if defined(HAVE_IOS_REGISTER_CALLBACK)  &&  
  61.   (!defined(NCBI_COMPILER_WORKSHOP)  ||  !defined(_MT))
  62. #  define HAVE_GOOD_IOS_CALLBACKS 1
  63. #endif
  66. BEGIN_NCBI_SCOPE
  69. /*****************************************************************************
  70.  *  Helper class: internal streambuf to be substituted instead of
  71.  *  the original one in the stream, when the data are pushed back.
  72.  */
  74. class CPushback_Streambuf : public CPushback_StreambufBase
  75. {
  76.     friend struct CStreamUtils;
  78. public:
  79.     CPushback_Streambuf(istream& istream, CT_CHAR_TYPE* buf,
  80.                         streamsize buf_size, void* del_ptr);
  81.     virtual ~CPushback_Streambuf();
  83. protected:
  84.     virtual CT_POS_TYPE seekoff(CT_OFF_TYPE off, IOS_BASE::seekdir whence,
  85.                                 IOS_BASE::openmode which);
  86.     virtual CT_POS_TYPE seekpos(CT_POS_TYPE pos, IOS_BASE::openmode which);
  88.     virtual CT_INT_TYPE overflow(CT_INT_TYPE c);
  89.     virtual streamsize  xsputn(const CT_CHAR_TYPE* buf, streamsize n);
  90.     virtual CT_INT_TYPE underflow(void);
  91.     virtual streamsize  xsgetn(CT_CHAR_TYPE* buf, streamsize n);
  92.     virtual streamsize  showmanyc(void);
  94.     virtual CT_INT_TYPE pbackfail(CT_INT_TYPE c = CT_EOF);
  96.     virtual int         sync(void);
  98.     // declared setbuf here to only throw an exception at run-time
  99.     virtual streambuf*  setbuf(CT_CHAR_TYPE* buf, streamsize buf_size);
  101. private:
  102.     void                x_FillBuffer(streamsize max_size);
  103.     void                x_DropBuffer(void);
  105.     istream&            m_Is;      // I/O stream this streambuf is attached to
  106.     streambuf*          m_Sb;      // original streambuf
  107.     CT_CHAR_TYPE*       m_Buf;     // == 0 when the buffer has been emptied
  108.     streamsize          m_BufSize;
  109.     void*               m_DelPtr;
  111. #ifdef HAVE_GOOD_IOS_CALLBACKS
  112.     int                 m_Index;
  113.     static void         x_Callback(IOS_BASE::event, IOS_BASE&, int);
  114. #endif //HAVE_GOOD_IOS_CALLBACKS
  116.     static const streamsize k_MinBufSize;
  117. };
  120. const streamsize CPushback_Streambuf::k_MinBufSize = 4096;
  123. #ifdef HAVE_GOOD_IOS_CALLBACKS
  124. void CPushback_Streambuf::x_Callback(IOS_BASE::event event,
  125.                                      IOS_BASE&       ios,
  126.                                      int             index)
  127. {
  128.     if (event == IOS_BASE::erase_event)
  129.         delete static_cast<streambuf*> (ios.pword(index));
  130. }
  131. #endif //HAVE_GOOD_IOS_CALLBACKS
  134. CPushback_Streambuf::CPushback_Streambuf(istream&      is,
  135.                                          CT_CHAR_TYPE* buf,
  136.                                          streamsize    buf_size,
  137.                                          void*         del_ptr) :
  138.     m_Is(is), m_Buf(buf), m_BufSize(buf_size), m_DelPtr(del_ptr)
  139. {
  140.     setp(0, 0); // unbuffered output at this level of streambuf's hierarchy
  141.     setg(m_Buf, m_Buf, m_Buf + m_BufSize);
  142.     m_Sb = m_Is.rdbuf(this);
  143. #ifdef HAVE_GOOD_IOS_CALLBACKS
  144.     try {
  145.         m_Index             = m_Is.xalloc();
  146.         m_Is.pword(m_Index) = this;
  147.         m_Is.register_callback(x_Callback, m_Index);
  148.     }
  149.     STD_CATCH_ALL("CPushback_Streambuf::CPushback_Streambuf");
  150. #endif //HAVE_GOOD_IOS_CALLBACKS
  151. }
  154. CPushback_Streambuf::~CPushback_Streambuf()
  155. {
  156. #ifdef HAVE_GOOD_IOS_CALLBACKS
  157.     m_Is.pword(m_Index) = 0;
  158. #endif //HAVE_GOOD_IOS_CALLBACKS
  159.     delete[] (CT_CHAR_TYPE*) m_DelPtr;
  160.     if (m_Sb) {
  161.         m_Is.rdbuf(m_Sb);
  162.         if (dynamic_cast<CPushback_Streambuf*> (m_Sb))
  163.             delete m_Sb;
  164.     }
  165. }
  168. CT_POS_TYPE CPushback_Streambuf::seekoff(CT_OFF_TYPE off,
  169.                                          IOS_BASE::seekdir whence,
  170.                                          IOS_BASE::openmode which)
  171. {
  172.     x_DropBuffer();
  173.     if (whence == ios::cur  &&  (which & ios::in)) {
  174.         return (CT_POS_TYPE)((CT_OFF_TYPE)(-1));
  175.     }
  176.     return m_Sb->PUBSEEKOFF(off, whence, which);
  177. }
  180. CT_POS_TYPE CPushback_Streambuf::seekpos(CT_POS_TYPE pos,
  181.                                          IOS_BASE::openmode which)
  182. {
  183.     x_DropBuffer();
  184.     return m_Sb->PUBSEEKPOS(pos, which);
  185. }
  188. CT_INT_TYPE CPushback_Streambuf::overflow(CT_INT_TYPE c)
  189. {
  190.     if ( !CT_EQ_INT_TYPE(c, CT_EOF) ) {
  191.         return m_Sb->sputc(CT_TO_CHAR_TYPE(c));
  192.     }
  194.     return m_Sb->PUBSYNC() == 0 ? CT_NOT_EOF(CT_EOF) : CT_EOF;
  195. }
  198. streamsize CPushback_Streambuf::xsputn(const CT_CHAR_TYPE* buf, streamsize n)
  199. {
  200.     // hope that this is an optimized copy operation (instead of overflow()s)
  201.     return m_Sb->sputn(buf, n);
  202. }
  205. CT_INT_TYPE CPushback_Streambuf::underflow(void)
  206. {
  207.     // we are here because there is no more data in the pushback buffer
  208.     _ASSERT(gptr()  &&  gptr() >= egptr());
  210. #ifdef NCBI_COMPILER_MIPSPRO
  211.     if (m_MIPSPRO_ReadsomeGptrSetLevel  &&  m_MIPSPRO_ReadsomeGptr != gptr())
  212.         return CT_EOF;
  213.     m_MIPSPRO_ReadsomeGptr = (CT_CHAR_TYPE*)(-1L);
  214. #endif //NCBI_COMPILER_MIPSPRO
  216.     x_FillBuffer(m_Sb->in_avail());
  217.     return gptr() < egptr() ? CT_TO_INT_TYPE(*gptr()) : CT_EOF;
  218. }
  221. streamsize CPushback_Streambuf::xsgetn(CT_CHAR_TYPE* buf, streamsize m)
  222. {
  223.     size_t n_total = 0;
  224.     while (m) {
  225.         if (gptr() < egptr()) {
  226.             size_t n       = (size_t) m;
  227.             size_t n_avail = (size_t) (egptr() - gptr());
  228.             size_t n_read  = (n <= n_avail) ? n : n_avail;
  229.             memcpy(buf, gptr(), n_read*sizeof(CT_CHAR_TYPE));
  230.             gbump((int) n_read);
  231.             m       -= (streamsize) n_read;
  232.             buf     += (streamsize) n_read;
  233.             n_total += (streamsize) n_read;
  234.         } else {
  235.             x_FillBuffer(m);
  236.             if (gptr() >= egptr())
  237.                 break;
  238.         }
  239.     }
  240.     return n_total;
  241. }
  244. streamsize CPushback_Streambuf::showmanyc(void)
  245. {
  246.     // we are here because (according to the standard) gptr() >= egptr()
  247.     _ASSERT(gptr()  &&  gptr() >= egptr());
  249.     return m_Sb->in_avail();
  250. }
  253. CT_INT_TYPE CPushback_Streambuf::pbackfail(CT_INT_TYPE /*c*/)
  254. {
  255.     /* We always maintain "usual backup condition" (27.5.2.4.3.13) after
  256.      * underflow(), i.e. 1 byte backup after a good read is always possible.
  257.      * That is, this function gets called only if the user tries to
  258.      * back up more than once (although, some attempts may be successful,
  259.      * this function call denotes that the backup area is full).
  260.      */
  261.     return CT_EOF; // always fail
  262. }
  265. int CPushback_Streambuf::sync(void)
  266. {
  267.     return m_Sb->PUBSYNC();
  268. }
  271. streambuf* CPushback_Streambuf::setbuf(CT_CHAR_TYPE* /*buf*/,
  272.                                        streamsize    /*buf_size*/)
  273. {
  274.     NCBI_THROW(CUtilException, eWrongCommand,
  275.                "CPushback_Streambuf::setbuf: not allowed");
  276.     /*NOTREACHED*/
  277.     return this;
  278. }
  281. void CPushback_Streambuf::x_FillBuffer(streamsize max_size)
  282. {
  283.     _ASSERT(m_Sb);
  284.     if ( !max_size )
  285.         ++max_size;
  286.     CPushback_Streambuf* sb = dynamic_cast<CPushback_Streambuf*> (m_Sb);
  287.     if ( sb ) {
  288.         _ASSERT(&m_Is == &sb->m_Is);
  289.         m_Sb     = sb->m_Sb;
  290.         sb->m_Sb = 0;
  291.         if (sb->gptr() >= sb->egptr()) {
  292.             delete sb;
  293.             x_FillBuffer(max_size);
  294.             return;
  295.         }
  296.         delete[] (CT_CHAR_TYPE*) m_DelPtr;
  297.         m_Buf        = sb->m_Buf;
  298.         m_BufSize    = sb->m_BufSize;
  299.         m_DelPtr     = sb->m_DelPtr;
  300.         sb->m_DelPtr = 0;
  301.         setg(sb->gptr(), sb->gptr(), sb->egptr());
  302.         delete sb;
  303.     } else {
  304.         CT_CHAR_TYPE* bp = 0;
  305.         streamsize buf_size = m_DelPtr
  306.             ? (streamsize)(m_Buf - (CT_CHAR_TYPE*) m_DelPtr) + m_BufSize : 0;
  307.         if (buf_size < k_MinBufSize) {
  308.             buf_size = k_MinBufSize;
  309.             bp = new CT_CHAR_TYPE[buf_size];
  310.         }
  311.         streamsize n = m_Sb->sgetn(bp ? bp : (CT_CHAR_TYPE*) m_DelPtr,
  312.                                    min(buf_size, max_size));
  313.         if (n <= 0) {
  314.             // NB: For unknown reasons WorkShop6 can return -1 from sgetn :-/
  315.             delete bp;
  316.             return;
  317.         }
  318.         if (bp) {
  319.             delete[] (CT_CHAR_TYPE*) m_DelPtr;
  320.             m_DelPtr = bp;
  321.         }
  322.         m_Buf = (CT_CHAR_TYPE*) m_DelPtr;
  323.         m_BufSize = buf_size;
  324.         setg(m_Buf, m_Buf, m_Buf + n);
  325.     }
  326. }
  329. void CPushback_Streambuf::x_DropBuffer()
  330. {
  331.     CPushback_Streambuf* sb = dynamic_cast<CPushback_Streambuf*> (m_Sb);
  332.     if (sb) {
  333.         m_Sb     = sb->m_Sb;
  334.         sb->m_Sb = 0;
  335.         delete sb;
  336.         x_DropBuffer();
  337.         return;
  338.     }
  339.     // nothing in the buffer; no putback area as well
  340.     setg(m_Buf, m_Buf, m_Buf);
  341. }
  344. /*****************************************************************************
  345.  *  Public interface
  346.  */
  349. void CStreamUtils::Pushback(CNcbiIstream& is,
  350.                             CT_CHAR_TYPE* buf,
  351.                             streamsize    buf_size,
  352.                             void*         del_ptr)
  353. {
  354.     CPushback_Streambuf* sb = dynamic_cast<CPushback_Streambuf*> (is.rdbuf());
  355.     _ASSERT(del_ptr <= buf);
  356.     if ( sb ) {
  357.         // We may not need to create another streambuf,
  358.         //     just recycle the existing one here...
  359.         _ASSERT(del_ptr < (sb->m_DelPtr ? sb->m_DelPtr : sb->m_Buf)  ||
  360.                 sb->m_Buf + sb->m_BufSize <= del_ptr);
  361.         // 1/ points to a (adjacent) part of the internal buffer we just read?
  362.         if (sb->m_Buf <= buf  &&  buf + buf_size == sb->gptr()) {
  363.             _ASSERT(!del_ptr  ||  del_ptr == sb->m_DelPtr);
  364.             sb->setg(buf, buf, sb->m_Buf + sb->m_BufSize);
  365.             return;
  366.         }
  367.         // 2/ equal to a (adjacent) part of the internal buffer we just read?
  368.         if ((streamsize)(sb->gptr() - sb->m_Buf) >= buf_size) {
  369.             CT_CHAR_TYPE* bp = sb->gptr() - buf_size;
  370.             if (memcmp(buf, bp, buf_size) == 0) {
  371.                 sb->setg(bp, bp, sb->egptr());
  372.                 if ( del_ptr ) {
  373.                     delete[] (CT_CHAR_TYPE*) del_ptr;
  374.                 }
  375.                 return;
  376.             }
  377.         }
  378.     }
  380.     (void) new CPushback_Streambuf(is, buf, buf_size, del_ptr);
  381. }
  384. void CStreamUtils::Pushback(CNcbiIstream&       is,
  385.                             const CT_CHAR_TYPE* buf,
  386.                             streamsize          buf_size)
  387. {
  388.     CT_CHAR_TYPE* buf_copy = new CT_CHAR_TYPE[buf_size];
  389.     memcpy(buf_copy, buf, buf_size);
  390.     Pushback(is, buf_copy, buf_size, buf_copy);
  391. }
  394. #ifdef NCBI_NO_READSOME
  395. #  undef NCBI_NO_READSOME
  396. #endif /*NCBI_NO_READSOME*/
  398. #if defined(NCBI_COMPILER_GCC)
  399. #  if NCBI_COMPILER_VERSION < 300
  400. #    define NCBI_NO_READSOME 1
  401. #  endif /*NCBI_COMPILER_VERSION*/
  402. #elif defined(NCBI_COMPILER_MSVC)
  403.     /* MSVC's readsome() is buggy [causes 1 byte reads] and is thus avoided.
  404.      * Now when we have worked around the issue by implementing fastopen()
  405.      * in CNcbiFstreams and thus making them fully buffered, we can go back
  406.      * to the use of readsome() in MSVC... */
  407.     //#  define NCBI_NO_READSOME 1
  408. #elif defined(NCBI_COMPILER_MIPSPRO)
  409.     /* MIPSPro does not comply with the standard and always checks for EOF
  410.      * doing one extra read from the stream [which might be a killing idea
  411.      * for network connections]. We introduced an ugly workaround here...
  412.      * Don't use istream::readsome() but istream::read() instead in order to be
  413.      * able to clear fake EOF caused by the unnecessary underflow() upcall.*/
  414. #  define NCBI_NO_READSOME 1
  415. #endif /*NCBI_COMPILER*/
  418. #ifndef NCBI_NO_READSOME
  419. static inline streamsize s_Readsome(CNcbiIstream& is,
  420.                                     CT_CHAR_TYPE* buf,
  421.                                     streamsize    buf_size)
  422. {
  423. #  ifdef NCBI_COMPILER_WORKSHOP
  424.     /* Rogue Wave does not always return correct value from is.readsome() :-/
  425.      * In particular, when streambuf::showmanyc() returns 1 followed by
  426.      * a failed read() [which implements extraction from the stream], which
  427.      * encounters the EOF, the readsome() will blindly return 1, and in
  428.      * general, always exactly the number of bytes showmanyc() reported,
  429.      * regardless of actually extracted by subsequent read operation.  Bug!
  430.      * NOTE that showmanyc() does not guarantee the number of bytes that can
  431.      * be read, but returns a best guess estimate [C++ Standard, footnote 275].
  432.      */
  433.     streamsize n = is.readsome(buf, buf_size);
  434.     return n ? is.gcount() : 0;
  435. #  else
  436.     return is.readsome(buf, buf_size);
  437. #  endif /*NCBI_COMPILER_WORKSHOP*/
  438. }
  439. #endif /*NCBI_NO_READSOME*/
  442. static streamsize s_DoReadsome(CNcbiIstream& is,
  443.                                CT_CHAR_TYPE* buf,
  444.                                streamsize    buf_size)
  445. {
  446.     _ASSERT(buf  &&  buf_size);
  447. #ifdef NCBI_NO_READSOME
  448. #  undef NCBI_NO_READSOME
  449.     // Special case: GCC had no readsome() prior to ver 3.0;
  450.     // read() will set "eof" (and "fail") flag if gcount() < buf_size
  451.     streamsize avail = is.rdbuf()->in_avail();
  452.     if (avail == 0)
  453.         avail++; // we still must read
  454.     else if (buf_size < avail)
  455.         avail = buf_size;
  456.     is.read(buf, avail);
  457.     streamsize count = is.gcount();
  458.     // Reset "eof" flag if some data have been read
  459.     if (count  &&  is.eof()  &&  !is.bad())
  460.         is.clear();
  461.     return count;
  462. #else
  463.     // Try to read data
  464.     streamsize n = s_Readsome(is, buf, buf_size);
  465.     if (n != 0  ||  !is.good())
  466.         return n;
  467.     // No buffered data found, try to read from the real source [still good]
  468.     is.read(buf, 1);
  469.     if ( !is.good() )
  470.         return 0;
  471.     if (buf_size == 1)
  472.         return 1; // do not need more data
  473.     // Read more data (up to "buf_size" bytes)
  474.     return s_Readsome(is, buf + 1, buf_size - 1) + 1;
  475. #endif /*NCBI_NO_READSOME*/
  476. }
  479. streamsize CStreamUtils::Readsome(CNcbiIstream& is,
  480.                                   CT_CHAR_TYPE* buf,
  481.                                   streamsize    buf_size)
  482. {
  483. #  ifdef NCBI_COMPILER_MIPSPRO
  484.     CMIPSPRO_ReadsomeTolerantStreambuf* sb =
  485.         dynamic_cast<CMIPSPRO_ReadsomeTolerantStreambuf*> (is.rdbuf());
  486.     if (sb)
  487.         sb->MIPSPRO_ReadsomeBegin();
  488. #  endif /*NCBI_COMPILER_MIPSPRO*/
  489.     streamsize result = s_DoReadsome(is, buf, buf_size);
  490. #  ifdef NCBI_COMPILER_MIPSPRO
  491.     if (sb)
  492.         sb->MIPSPRO_ReadsomeEnd();
  493. #  endif /*NCBI_COMPILER_MIPSPRO*/
  494.     return result;
  495. }
  498. END_NCBI_SCOPE
  501. /*
  502.  * ---------------------------------------------------------------------------
  503.  * $Log: stream_utils.cpp,v $
  504.  * Revision 1000.4  2004/06/01 19:40:35  gouriano
  505.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.42
  506.  *
  507.  * Revision 1.42  2004/05/17 21:06:02  gorelenk
  508.  * Added include of PCH ncbi_pch.hpp
  509.  *
  510.  * Revision 1.41  2004/02/03 13:13:46  lavr
  511.  * ios::xalloc() is universal; HAVE_XALLOC is deprecated and removed
  512.  *
  513.  * Revision 1.40  2004/01/21 15:34:14  lavr
  514.  * Use proper macro HAVE_IOS_REGISTER_CALLBACK
  515.  *
  516.  * Revision 1.39  2004/01/20 20:39:59  lavr
  517.  * Replace HAVE_BUGGY_IOS_CALLBACKS with (better) HAVE_GOOD_IOS_CALLBACKS
  518.  *
  519.  * Revision 1.38  2003/12/31 16:24:54  lavr
  520.  * Fix istream::readsome() return counter use for Rogue Wave implementations
  521.  *
  522.  * Revision 1.37  2003/12/31 15:31:20  lavr
  523.  * Fix wrong use of istream::readsome() on platforms that lack it
  524.  *
  525.  * Revision 1.36  2003/12/30 17:28:39  lavr
  526.  * Work around buggy implementation of istream::readsome() in Rogue Wave STL
  527.  *
  528.  * Revision 1.35  2003/12/29 15:18:40  lavr
  529.  * Modified CStreamUtils::Readsome() to avoid blocking on GCC2.95
  530.  *
  531.  * Revision 1.34  2003/12/18 13:24:46  ucko
  532.  * It seems MIPSpro also lacks showmanyc, so extend our
  533.  * streambuf-with-showmanyc class to cover it as well and make it
  534.  * CMIPSPRO_ReadsomeTolerantStreambuf's base class; also use it as
  535.  * CPushback_StreambufBase's base class with GCC 2.9x.
  536.  *
  537.  * Revision 1.33  2003/12/18 03:44:29  ucko
  538.  * s_Readsome(): If in_avail() and showmanyc() both return 0, do likewise
  539.  * rather than potentially blocking.
  540.  *
  541.  * Revision 1.32  2003/11/21 19:58:47  lavr
  542.  * x_FillBuffer() not to have default parameter: crucial in underflow()
  543.  *
  544.  * Revision 1.31  2003/11/19 16:49:35  vasilche
  545.  * Fix previous commit to maintain backup condition.
  546.  *
  547.  * Revision 1.30  2003/11/19 15:41:50  vasilche
  548.  * Temporary fix for wrong Readsome() after Pushback().
  549.  *
  550.  * Revision 1.29  2003/11/04 13:39:01  lavr
  551.  * CPushback_Streambuf is conditionally based on MIPSPro
  552.  *
  553.  * Revision 1.28  2003/11/03 20:05:11  lavr
  554.  * CStreamUtils::Readsome() reorganized: s_Readsome() introduced.
  555.  * Add and elaborate notes about I/O on MSVC and MIPSPro.
  556.  * Allow to use stream readsome() on these two compilers.
  557.  *
  558.  * Revision 1.27  2003/10/22 18:11:24  lavr
  559.  * Change base class of CPushback_Streambuf into CNcbiStreambuf
  560.  *
  561.  * Revision 1.26  2003/10/16 19:37:36  lavr
  562.  * Add comments and indentation of conditionals in Readsome()
  563.  *
  564.  * Revision 1.25  2003/05/21 19:34:34  lavr
  565.  * Note that insufficient ios::read() also sets failbit (as per the standard)
  566.  *
  567.  * Revision 1.24  2003/05/20 16:44:59  lavr
  568.  * CStreamUtils::Readsome() not to clear() in a bad() stream
  569.  *
  570.  * Revision 1.23  2003/04/14 21:08:39  lavr
  571.  * Take advantage of HAVE_BUGGY_IOS_CALLBACKS
  572.  *
  573.  * Revision 1.22  2003/04/11 17:57:52  lavr
  574.  * Take advantage of HAVE_IOS_XALLOC
  575.  *
  576.  * Revision 1.21  2003/03/30 07:00:36  lavr
  577.  * MIPS-specific workaround for lame-designed stream read ops
  578.  *
  579.  * Revision 1.20  2003/03/28 03:26:15  lavr
  580.  * Reinstate NCBI_NO_READSOME for MSVC
  581.  *
  582.  * Revision 1.19  2003/03/27 18:40:14  lavr
  583.  * Temporarily remove NCBI_NO_READSOME for MSVC
  584.  *
  585.  * Revision 1.18  2003/03/27 16:50:14  lavr
  586.  * #define NCBI_NO_READSOME for MSVC to prevent 1-byte at a time file input
  587.  * caused by lame unbuffered implementation of basic_filebuf, that defines
  588.  * showmanyc() to return 0 and doing byte-by-byte file input via fgetc()
  589.  *
  590.  * Revision 1.17  2003/03/25 22:14:03  lavr
  591.  * CStreamUtils::Readsome(): Return not only on EOF but on any !good()
  592.  *
  593.  * Revision 1.16  2003/02/27 15:36:23  lavr
  594.  * Preper indentation for NCBI_THROW
  595.  *
  596.  * Revision 1.15  2003/02/26 21:32:00  gouriano
  597.  * modify C++ exceptions thrown by this library
  598.  *
  599.  * Revision 1.14  2002/12/19 14:50:42  dicuccio
  600.  * Changed a friend class -> friend struct (relieves a warning for MSVC)
  601.  *
  602.  * Revision 1.13  2002/11/28 03:28:01  lavr
  603.  * Comments updated
  604.  *
  605.  * Revision 1.12  2002/11/27 21:08:01  lavr
  606.  * Rename "stream_pushback" -> "stream_utils" and enclose utils in a class
  607.  * Add new utility method Readsome() for non-blocking read
  608.  *
  609.  * Revision 1.11  2002/10/29 22:06:27  ucko
  610.  * Make *buf const in the copying version of UTIL_StreamPushback.
  611.  *
  612.  * Revision 1.10  2002/09/17 20:47:05  lavr
  613.  * Add a comment to unreachable return from CPushback_Streambuf::setbuf()
  614.  *
  615.  * Revision 1.9  2002/08/16 17:56:44  lavr
  616.  * PUBSYNC, PUBSEEK* moved to <corelib/ncbistre.hpp>
  617.  *
  618.  * Revision 1.8  2002/02/06 14:38:23  ucko
  619.  * Split up conditional test for GCC2.x to work around KCC preprocessor lossage
  620.  *
  621.  * Revision 1.7  2002/02/05 16:05:43  lavr
  622.  * List of included header files revised
  623.  *
  624.  * Revision 1.6  2002/02/04 20:22:34  lavr
  625.  * Stream positioning added; more assert()'s to check standard compliance
  626.  *
  627.  * Revision 1.5  2002/01/28 20:26:39  lavr
  628.  * Completely redesigned
  629.  *
  630.  * Revision 1.4  2001/12/17 22:18:21  ucko
  631.  * Overload xsgetn unconditionally.
  632.  *
  633.  * Revision 1.3  2001/12/13 17:21:27  vakatov
  634.  * [GCC, NCBI_COMPILER_VERSION > 2.95.X]  Use pubsync() rather than sync()
  635.  *
  636.  * Revision 1.2  2001/12/09 06:31:52  vakatov
  637.  * UTIL_StreamPushback() to return VOID rather than STREAMBUF*.
  638.  * Got rid of a warning;  added comments;  use _ASSERT(), not assert().
  639.  *
  640.  * Revision 1.1  2001/12/07 22:59:36  lavr
  641.  * Initial revision
  642.  *
  643.  * ===========================================================================
  644. */