30 #ifndef _LOCALE_CONV_H
31 #define _LOCALE_CONV_H 1
33 #if __cplusplus < 201103L
43 namespace std _GLIBCXX_VISIBILITY(default)
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
47 #ifdef _GLIBCXX_USE_WCHAR_T
55 template<
typename _Codecvt,
typename _Elem = wchar_t,
56 typename _Wide_alloc = allocator<_Elem>,
57 typename _Byte_alloc = allocator<char>>
63 typedef typename _Codecvt::state_type state_type;
64 typedef typename wide_string::traits_type::int_type int_type;
76 __throw_logic_error(
"wstring_convert");
88 : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
91 __throw_logic_error(
"wstring_convert");
101 const wide_string& __wide_err = wide_string())
102 : _M_cvt(new _Codecvt),
103 _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
104 _M_with_strings(true)
107 __throw_logic_error(
"wstring_convert");
121 char __bytes[2] = { __byte };
132 auto __ptr = __str.
data();
139 auto __errstr = _M_with_strings ? &_M_wide_err_string :
nullptr;
140 _ConvFn<char, _Elem> __fn = &_Codecvt::in;
141 return _M_conv(__first, __last, __errstr, __fn);
149 _Elem __wchars[2] = { __wchar };
150 return to_bytes(__wchars, __wchars+1);
156 return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
162 auto __ptr = __wstr.
data();
167 to_bytes(
const _Elem* __first,
const _Elem* __last)
169 auto __errstr = _M_with_strings ? &_M_byte_err_string :
nullptr;
170 _ConvFn<_Elem, char> __fn = &_Codecvt::out;
171 return _M_conv(__first, __last, __errstr, __fn);
181 state_type
state()
const {
return _M_state; }
184 template<
typename _InC,
typename _OutC>
186 = codecvt_base::result
187 (_Codecvt::*)(state_type&,
const _InC*,
const _InC*,
const _InC*&,
188 _OutC*, _OutC*, _OutC*&)
const;
190 template<
typename _InChar,
typename _OutStr,
typename _MemFn>
192 _M_conv(
const _InChar* __first,
const _InChar* __last,
193 const _OutStr* __err, _MemFn __memfn)
195 if (!_M_with_cvtstate)
196 _M_state = state_type();
198 auto __outstr = __err ? _OutStr(__err->get_allocator()) : _OutStr();
199 size_t __outchars = 0;
200 auto __next = __first;
201 const auto __maxlen = _M_cvt->max_length() + 1;
203 codecvt_base::result __result;
206 __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
207 auto __outnext = &__outstr.front() + __outchars;
208 auto const __outlast = &__outstr.back() + 1;
209 __result = ((*_M_cvt).*__memfn)(_M_state, __next, __last, __next,
210 __outnext, __outlast, __outnext);
211 __outchars = __outnext - &__outstr.front();
213 while (__result == codecvt_base::partial && __next != __last
214 && (__outstr.size() - __outchars) < __maxlen);
216 if (__result == codecvt_base::noconv)
218 __outstr.assign(__first, __last);
219 _M_count = __outstr.size();
223 __outstr.resize(__outchars);
224 _M_count = __next - __first;
226 if (__result != codecvt_base::error)
231 __throw_range_error(
"wstring_convert");
234 unique_ptr<_Codecvt> _M_cvt;
235 byte_string _M_byte_err_string;
236 wide_string _M_wide_err_string;
237 state_type _M_state = state_type();
239 bool _M_with_cvtstate =
false;
240 bool _M_with_strings =
false;
244 template<
typename _Codecvt,
typename _Elem = wchar_t,
245 typename _Tr = char_traits<_Elem>>
248 typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
251 typedef typename _Codecvt::state_type state_type;
263 state_type __state = state_type())
264 : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
267 __throw_logic_error(
"wstring_convert");
269 _M_always_noconv = _M_cvt->always_noconv();
273 this->setp(_M_put_area, _M_put_area + _S_buffer_length);
274 this->setg(_M_get_area + _S_putback_length,
275 _M_get_area + _S_putback_length,
276 _M_get_area + _S_putback_length);
287 streambuf* rdbuf() const noexcept {
return _M_buf; }
290 rdbuf(streambuf *__bytebuf) noexcept
292 auto __prev = _M_buf;
298 state_type
state() const noexcept {
return _M_state; }
303 {
return _M_buf && _M_conv_put() && _M_buf->pubsync() ? 0 : -1; }
305 typename _Wide_streambuf::int_type
306 overflow(
typename _Wide_streambuf::int_type __out)
308 if (!_M_buf || !_M_conv_put())
310 else if (!_Tr::eq_int_type(__out, _Tr::eof()))
311 return this->sputc(__out);
312 return _Tr::not_eof(__out);
315 typename _Wide_streambuf::int_type
321 if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
322 return _Tr::to_int_type(*this->gptr());
328 xsputn(
const typename _Wide_streambuf::char_type* __s,
streamsize __n)
330 if (!_M_buf || __n == 0)
335 auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
337 _Tr::copy(this->pptr(), __s + __done, __nn);
340 }
while (__done < __n && _M_conv_put());
349 const streamsize __pb1 = this->gptr() - this->eback();
353 _Tr::move(_M_get_area + _S_putback_length - __npb,
354 this->gptr() - __npb, __npb);
356 streamsize __nbytes =
sizeof(_M_get_buf) - _M_unconv;
357 __nbytes =
std::min(__nbytes, _M_buf->in_avail());
360 __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
363 __nbytes += _M_unconv;
367 _Elem* __outbuf = _M_get_area + _S_putback_length;
368 _Elem* __outnext = __outbuf;
369 const char* __bnext = _M_get_buf;
371 codecvt_base::result __result;
372 if (_M_always_noconv)
373 __result = codecvt_base::noconv;
376 _Elem* __outend = _M_get_area + _S_buffer_length;
378 __result = _M_cvt->in(_M_state,
379 __bnext, __bnext + __nbytes, __bnext,
380 __outbuf, __outend, __outnext);
383 if (__result == codecvt_base::noconv)
386 auto __get_buf =
reinterpret_cast<const _Elem*
>(_M_get_buf);
387 _Tr::copy(__outbuf, __get_buf, __nbytes);
392 if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
393 char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
395 this->setg(__outbuf, __outbuf, __outnext);
397 return __result != codecvt_base::error;
408 if (_M_buf->sputn(__p, __n) < __n)
416 _Elem*
const __first = this->pbase();
417 const _Elem*
const __last = this->pptr();
418 const streamsize __pending = __last - __first;
420 if (_M_always_noconv)
421 return _M_put(__first, __pending);
423 char __outbuf[2 * _S_buffer_length];
425 const _Elem* __next = __first;
426 const _Elem* __start;
430 char* __outnext = __outbuf;
431 char*
const __outlast = __outbuf +
sizeof(__outbuf);
432 auto __result = _M_cvt->out(_M_state, __next, __last, __next,
433 __outnext, __outlast, __outnext);
434 if (__result == codecvt_base::error)
436 else if (__result == codecvt_base::noconv)
437 return _M_put(__next, __pending);
439 if (!_M_put(__outbuf, __outnext - __outbuf))
442 while (__next != __last && __next != __start);
444 if (__next != __last)
445 _Tr::move(__first, __next, __last - __next);
447 this->pbump(__first - __next);
448 return __next != __first;
452 unique_ptr<_Codecvt> _M_cvt;
455 static const streamsize _S_buffer_length = 32;
456 static const streamsize _S_putback_length = 3;
457 _Elem _M_put_area[_S_buffer_length];
458 _Elem _M_get_area[_S_buffer_length];
460 char _M_get_buf[_S_buffer_length-_S_putback_length];
461 bool _M_always_noconv;
466 #endif // _GLIBCXX_USE_WCHAR_T
468 _GLIBCXX_END_NAMESPACE_VERSION
471 #endif // __cplusplus
Basis for explicit traits specializations.
wbuffer_convert(streambuf *__bytebuf=0, _Codecvt *__pcvt=new _Codecvt, state_type __state=state_type())
Managing sequences of characters and character-like objects.
wide_string from_bytes(char __byte)
Convert from bytes.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
wide_string from_bytes(const byte_string &__str)
Convert from bytes.
byte_string to_bytes(const _Elem *__ptr)
Convert to bytes.
state_type state() const noexcept
The conversion state following the last conversion.
const _CharT * data() const noexcept
Return const pointer to contents.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
wide_string from_bytes(const char *__first, const char *__last)
Convert from bytes.
wstring_convert(_Codecvt *__pcvt=new _Codecvt())
byte_string to_bytes(_Elem __wchar)
Convert to bytes.
byte_string to_bytes(const wide_string &__wstr)
Convert to bytes.
wstring_convert(const byte_string &__byte_err, const wide_string &__wide_err=wide_string())
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
state_type state() const
The final conversion state of the last conversion.
byte_string to_bytes(const _Elem *__first, const _Elem *__last)
Convert to bytes.
wstring_convert(_Codecvt *__pcvt, state_type __state)
wide_string from_bytes(const char *__ptr)
Convert from bytes.
ISO C++ entities toplevel namespace is std.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
size_t converted() const noexcept
The number of elements successfully converted in the last conversion.