contrib/gcc-8.0/libstdc++-v3/include/bits/streambuf.tcc

   1 // Stream buffer classes -*- C++ -*-
   2
   3 // Copyright (C) 1997-2018 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file bits/streambuf.tcc
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{streambuf}
  28  */
  29
  30 //
  31 // ISO C++ 14882: 27.5  Stream buffers
  32 //
  33
  34 #ifndef _STREAMBUF_TCC
  35 #define _STREAMBUF_TCC 1
  36
  37 #pragma GCC system_header
  38
  39 namespace std _GLIBCXX_VISIBILITY(default)
  40 {
  41 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  42
  43   template<typename _CharT, typename _Traits>
  44     streamsize
  45     basic_streambuf<_CharT, _Traits>::
  46     xsgetn(char_type* __s, streamsize __n)
  47     {
  48       streamsize __ret = 0;
  49       while (__ret < __n)
  50         {
  51           const streamsize __buf_len = this->egptr() - this->gptr();
  52           if (__buf_len)
  53             {
  54               const streamsize __remaining = __n - __ret;
  55               const streamsize __len = std::min(__buf_len, __remaining);
  56               traits_type::copy(__s, this->gptr(), __len);
  57               __ret += __len;
  58               __s += __len;
  59               this->__safe_gbump(__len);
  60             }
  61
  62           if (__ret < __n)
  63             {
  64               const int_type __c = this->uflow();
  65               if (!traits_type::eq_int_type(__c, traits_type::eof()))
  66                 {
  67                   traits_type::assign(*__s++, traits_type::to_char_type(__c));
  68                   ++__ret;
  69                 }
  70               else
  71                 break;
  72             }
  73         }
  74       return __ret;
  75     }
  76
  77   template<typename _CharT, typename _Traits>
  78     streamsize
  79     basic_streambuf<_CharT, _Traits>::
  80     xsputn(const char_type* __s, streamsize __n)
  81     {
  82       streamsize __ret = 0;
  83       while (__ret < __n)
  84         {
  85           const streamsize __buf_len = this->epptr() - this->pptr();
  86           if (__buf_len)
  87             {
  88               const streamsize __remaining = __n - __ret;
  89               const streamsize __len = std::min(__buf_len, __remaining);
  90               traits_type::copy(this->pptr(), __s, __len);
  91               __ret += __len;
  92               __s += __len;
  93               this->__safe_pbump(__len);
  94             }
  95
  96           if (__ret < __n)
  97             {
  98               int_type __c = this->overflow(traits_type::to_int_type(*__s));
  99               if (!traits_type::eq_int_type(__c, traits_type::eof()))
 100                 {
 101                   ++__ret;
 102                   ++__s;
 103                 }
 104               else
 105                 break;
 106             }
 107         }
 108       return __ret;
 109     }
 110
 111   // Conceivably, this could be used to implement buffer-to-buffer
 112   // copies, if this was ever desired in an un-ambiguous way by the
 113   // standard.
 114   template<typename _CharT, typename _Traits>
 115     streamsize
 116     __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
 117                           basic_streambuf<_CharT, _Traits>* __sbout,
 118                           bool& __ineof)
 119     {
 120       streamsize __ret = 0;
 121       __ineof = true;
 122       typename _Traits::int_type __c = __sbin->sgetc();
 123       while (!_Traits::eq_int_type(__c, _Traits::eof()))
 124         {
 125           __c = __sbout->sputc(_Traits::to_char_type(__c));
 126           if (_Traits::eq_int_type(__c, _Traits::eof()))
 127             {
 128               __ineof = false;
 129               break;
 130             }
 131           ++__ret;
 132           __c = __sbin->snextc();
 133         }
 134       return __ret;
 135     }
 136
 137   template<typename _CharT, typename _Traits>
 138     inline streamsize
 139     __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
 140                       basic_streambuf<_CharT, _Traits>* __sbout)
 141     {
 142       bool __ineof;
 143       return __copy_streambufs_eof(__sbin, __sbout, __ineof);
 144     }
 145
 146   // Inhibit implicit instantiations for required instantiations,
 147   // which are defined via explicit instantiations elsewhere.
 148 #if _GLIBCXX_EXTERN_TEMPLATE
 149   extern template class basic_streambuf<char>;
 150   extern template
 151     streamsize
 152     __copy_streambufs(basic_streambuf<char>*,
 153                       basic_streambuf<char>*);
 154   extern template
 155     streamsize
 156     __copy_streambufs_eof(basic_streambuf<char>*,
 157                           basic_streambuf<char>*, bool&);
 158
 159 #ifdef _GLIBCXX_USE_WCHAR_T
 160   extern template class basic_streambuf<wchar_t>;
 161   extern template
 162     streamsize
 163     __copy_streambufs(basic_streambuf<wchar_t>*,
 164                       basic_streambuf<wchar_t>*);
 165   extern template
 166     streamsize
 167     __copy_streambufs_eof(basic_streambuf<wchar_t>*,
 168                           basic_streambuf<wchar_t>*, bool&);
 169 #endif
 170 #endif
 171
 172 _GLIBCXX_END_NAMESPACE_VERSION
 173 } // namespace std
 174
 175 #endif