strbuffer.inl
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:8k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: strbuffer.inl,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:38:59  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.5
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. #if defined(STRBUFFER__HPP)  &&  !defined(STRBUFFER__INL)
  10. #define STRBUFFER__INL
  11. /*  $Id: strbuffer.inl,v 1000.1 2004/06/01 19:38:59 gouriano Exp $
  12. * ===========================================================================
  13. *
  14. *                            PUBLIC DOMAIN NOTICE
  15. *               National Center for Biotechnology Information
  16. *
  17. *  This software/database is a "United States Government Work" under the
  18. *  terms of the United States Copyright Act.  It was written as part of
  19. *  the author's official duties as a United States Government employee and
  20. *  thus cannot be copyrighted.  This software/database is freely available
  21. *  to the public for use. The National Library of Medicine and the U.S.
  22. *  Government have not placed any restriction on its use or reproduction.
  23. *
  24. *  Although all reasonable efforts have been taken to ensure the accuracy
  25. *  and reliability of the software and data, the NLM and the U.S.
  26. *  Government do not and cannot warrant the performance or results that
  27. *  may be obtained by using this software or data. The NLM and the U.S.
  28. *  Government disclaim all warranties, express or implied, including
  29. *  warranties of performance, merchantability or fitness for any particular
  30. *  purpose.
  31. *
  32. *  Please cite the author in any work or product based on this material.
  33. *
  34. * ===========================================================================
  35. *
  36. * Author: Eugene Vasilchenko
  37. *
  38. * File Description:
  39. *   !!! PUT YOUR DESCRIPTION HERE !!!
  40. *
  41. * ---------------------------------------------------------------------------
  42. * $Log: strbuffer.inl,v $
  43. * Revision 1000.1  2004/06/01 19:38:59  gouriano
  44. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.5
  45. *
  46. * Revision 1.5  2004/05/24 18:12:44  gouriano
  47. * In text output files make indentation optional
  48. *
  49. * Revision 1.4  2001/08/15 20:53:09  juran
  50. * Heed warnings.
  51. *
  52. * Revision 1.3  2001/03/14 17:59:24  vakatov
  53. * COStreamBuffer::  renamed GetFreeSpace() -> GetAvailableSpace()
  54. * to avoid clash with MS-Win system headers' #define
  55. *
  56. * Revision 1.2  2001/01/05 20:08:53  vasilche
  57. * Added util directory for various algorithms and utility classes.
  58. *
  59. * Revision 1.1  2000/12/26 22:23:45  vasilche
  60. * Fixed errors of compilation on Mac.
  61. *
  62. * ===========================================================================
  63. */
  64. inline
  65. bool CIStreamBuffer::fail(void) const
  66. {
  67.     return m_Error != 0;
  68. }
  69. inline
  70. void CIStreamBuffer::ResetFail(void)
  71. {
  72.     m_Error = 0;
  73. }
  74. inline
  75. const char* CIStreamBuffer::GetError(void) const
  76. {
  77.     return m_Error;
  78. }
  79. inline
  80. char CIStreamBuffer::PeekChar(size_t offset)
  81.     THROWS1((CIOException, bad_alloc))
  82. {
  83.     char* pos = m_CurrentPos + offset;
  84.     if ( pos >= m_DataEndPos )
  85.         pos = FillBuffer(pos);
  86.     return *pos;
  87. }
  88. inline
  89. char CIStreamBuffer::PeekCharNoEOF(size_t offset)
  90.     THROWS1((CIOException, bad_alloc))
  91. {
  92.     char* pos = m_CurrentPos + offset;
  93.     if ( pos >= m_DataEndPos )
  94.         return FillBufferNoEOF(pos);
  95.     return *pos;
  96. }
  97. inline
  98. char CIStreamBuffer::GetChar(void)
  99.     THROWS1((CIOException, bad_alloc))
  100. {
  101.     char* pos = m_CurrentPos;
  102.     if ( pos >= m_DataEndPos )
  103.         pos = FillBuffer(pos);
  104.     m_CurrentPos = pos + 1;
  105.     return *pos;
  106. }
  107. inline
  108. void CIStreamBuffer::UngetChar(char _DEBUG_ARG(c))
  109. {
  110.     char* pos = m_CurrentPos;
  111.     _ASSERT(pos > m_Buffer);
  112.     _ASSERT(pos[-1] == c);
  113.     m_CurrentPos = pos - 1;
  114. }
  115. inline
  116. void CIStreamBuffer::SkipChars(size_t count)
  117. {
  118.     _ASSERT(m_CurrentPos + count > m_CurrentPos);
  119.     _ASSERT(m_CurrentPos + count <= m_DataEndPos);
  120.     m_CurrentPos += count;
  121. }
  122. inline
  123. void CIStreamBuffer::SkipChar(void)
  124. {
  125.     SkipChars(1);
  126. }
  127. inline
  128. const char* CIStreamBuffer::GetCurrentPos(void) const
  129.     THROWS1_NONE
  130. {
  131.     return m_CurrentPos;
  132. }
  133. inline
  134. size_t CIStreamBuffer::GetLine(void) const
  135.     THROWS1_NONE
  136. {
  137.     return m_Line;
  138. }
  139. inline
  140. size_t CIStreamBuffer::GetStreamOffset(void) const
  141.     THROWS1_NONE
  142. {
  143.     return m_BufferOffset + (m_CurrentPos - m_Buffer);
  144. }
  145. inline
  146. bool COStreamBuffer::fail(void) const
  147. {
  148.     return m_Error != 0;
  149. }
  150. inline
  151. void COStreamBuffer::ResetFail(void)
  152. {
  153.     m_Error = 0;
  154. }
  155. inline
  156. const char* COStreamBuffer::GetError(void) const
  157. {
  158.     return m_Error;
  159. }
  160. inline
  161. size_t COStreamBuffer::GetLine(void) const
  162.     THROWS1_NONE
  163. {
  164.     return m_Line;
  165. }
  166. inline
  167. size_t COStreamBuffer::GetStreamOffset(void) const
  168.     THROWS1_NONE
  169. {
  170.     return m_BufferOffset + (m_CurrentPos - m_Buffer);
  171. }
  172. inline
  173. size_t COStreamBuffer::GetCurrentLineLength(void) const
  174.     THROWS1_NONE
  175. {
  176.     return m_LineLength;
  177. }
  178. inline
  179. bool COStreamBuffer::ZeroIndentLevel(void) const
  180.     THROWS1_NONE
  181. {
  182.     return m_IndentLevel == 0;
  183. }
  184. inline
  185. size_t COStreamBuffer::GetIndentLevel(size_t step) const
  186.     THROWS1_NONE
  187. {
  188.     return m_IndentLevel / step;
  189. }
  190. inline
  191. void COStreamBuffer::IncIndentLevel(size_t step)
  192.     THROWS1_NONE
  193. {
  194.     m_IndentLevel += step;
  195. }
  196. inline
  197. void COStreamBuffer::DecIndentLevel(size_t step)
  198.     THROWS1_NONE
  199. {
  200.     _ASSERT(m_IndentLevel >= step);
  201.     m_IndentLevel -= step;
  202. }
  203. inline
  204. void COStreamBuffer::SetBackLimit(size_t limit)
  205. {
  206.     m_BackLimit = limit;
  207. }
  208. inline
  209. char* COStreamBuffer::DoSkip(size_t reserve)
  210.     THROWS1((CIOException, bad_alloc))
  211. {
  212.     char* pos = DoReserve(reserve);
  213.     m_CurrentPos = pos + reserve;
  214.     m_LineLength += reserve;
  215.     return pos;
  216. }
  217. inline
  218. char* COStreamBuffer::Skip(size_t count)
  219.     THROWS1((CIOException, bad_alloc))
  220. {
  221.     char* pos = m_CurrentPos;
  222.     char* end = pos + count;
  223.     if ( end <= m_BufferEnd ) {
  224.         // enough space in buffer
  225.         m_CurrentPos = end;
  226.         m_LineLength += count;
  227.         return pos;
  228.     }
  229.     else {
  230.         return DoSkip(count);
  231.     }
  232. }
  233. inline
  234. char* COStreamBuffer::Reserve(size_t count)
  235.     THROWS1((CIOException, bad_alloc))
  236. {
  237.     char* pos = m_CurrentPos;
  238.     char* end = pos + count;
  239.     if ( end <= m_BufferEnd ) {
  240.         // enough space in buffer
  241.         return pos;
  242.     }
  243.     else {
  244.         return DoReserve(count);
  245.     }
  246. }
  247. inline
  248. void COStreamBuffer::PutChar(char c)
  249.     THROWS1((CIOException))
  250. {
  251.     *Skip(1) = c;
  252. }
  253. inline
  254. void COStreamBuffer::BackChar(char _DEBUG_ARG(c))
  255. {
  256.     _ASSERT(m_CurrentPos > m_Buffer);
  257.     --m_CurrentPos;
  258.     _ASSERT(*m_CurrentPos == c);
  259. }
  260. inline
  261. void COStreamBuffer::PutString(const char* str, size_t length)
  262.     THROWS1((CIOException, bad_alloc))
  263. {
  264.     if ( length < 1024 ) {
  265.         memcpy(Skip(length), str, length);
  266.     }
  267.     else {
  268.         Write(str, length);
  269.     }
  270. }
  271. inline
  272. void COStreamBuffer::PutString(const char* str)
  273.     THROWS1((CIOException, bad_alloc))
  274. {
  275.     PutString(str, strlen(str));
  276. }
  277. inline
  278. void COStreamBuffer::PutString(const string& str)
  279.     THROWS1((CIOException, bad_alloc))
  280. {
  281.     PutString(str.data(), str.size());
  282. }
  283. inline
  284. void COStreamBuffer::PutIndent(void)
  285.     THROWS1((CIOException, bad_alloc))
  286. {
  287.     if (GetUseIndentation()) {
  288.         size_t count = m_IndentLevel;
  289.         memset(Skip(count), ' ', count);
  290.     }
  291. }
  292. inline
  293. void COStreamBuffer::PutEol(bool indent)
  294.     THROWS1((CIOException, bad_alloc))
  295. {
  296.     char* pos = Reserve(1);
  297.     *pos = 'n';
  298.     m_CurrentPos = pos + 1;
  299.     ++m_Line;
  300.     m_LineLength = 0;
  301.     if ( indent )
  302.         PutIndent();
  303. }
  304. inline
  305. void COStreamBuffer::WrapAt(size_t lineLength, bool keepWord)
  306.     THROWS1((CIOException, bad_alloc))
  307. {
  308.     if ( keepWord ) {
  309.         if ( GetCurrentLineLength() > lineLength )
  310.             PutEolAtWordEnd(lineLength);
  311.     }
  312.     else {
  313.         if ( GetCurrentLineLength() >= lineLength )
  314.             PutEol(false);
  315.     }
  316. }
  317. inline
  318. size_t COStreamBuffer::GetUsedSpace(void) const
  319. {
  320.     return static_cast<size_t>(m_CurrentPos - m_Buffer);
  321. }
  322. inline
  323. size_t COStreamBuffer::GetAvailableSpace(void) const
  324. {
  325.     return static_cast<size_t>(m_BufferEnd - m_CurrentPos);
  326. }
  327. inline
  328. size_t COStreamBuffer::GetBufferSize(void) const
  329. {
  330.     return static_cast<size_t>(m_BufferEnd - m_Buffer);
  331. }
  332. inline
  333. void COStreamBuffer::SetUseIndentation(bool set)
  334. {
  335.     m_UseIndentation = set;
  336. }
  337. inline
  338. bool COStreamBuffer::GetUseIndentation(void) const
  339. {
  340.     return m_UseIndentation;
  341. }
  342. #endif /* def STRBUFFER__HPP  &&  ndef STRBUFFER__INL */