// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_SSTREAM #define _LIBCPP_SSTREAM // clang-format off /* sstream synopsis [sstream.syn] // Class template basic_stringbuf [stringbuf] template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_stringbuf : public basic_streambuf<charT, traits> { public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef Allocator allocator_type; // [stringbuf.cons] constructors: explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20 basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {} // C++20 explicit basic_stringbuf(ios_base::openmode which); // C++20 explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& s, ios_base::openmode which = ios_base::in | ios_base::out); explicit basic_stringbuf(const allocator_type& a) : basic_stringbuf(ios_base::in | ios_base::out, a) {} // C++20 basic_stringbuf(ios_base::openmode which, const allocator_type& a); // C++20 explicit basic_stringbuf(basic_string<char_type, traits_type, allocator_type>&& s, ios_base::openmode which = ios_base::in | ios_base::out); // C++20 template <class SAlloc> basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a) : basic_stringbuf(s, ios_base::in | ios_base::out, a) {} // C++20 template <class SAlloc> basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which, const allocator_type& a); // C++20 template <class SAlloc> explicit basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which = ios_base::in | ios_base::out); // C++20 template<class T> explicit basic_stringbuf(const T& t, ios_base::openmode which = ios_base::in | ios_base::out); // Since C++26 template<class T> basic_stringbuf(const T& t, const Allocator& a); // Since C++26 template<class T> basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a); // Since C++26 basic_stringbuf(const basic_stringbuf&) = delete; basic_stringbuf(basic_stringbuf&& rhs); basic_stringbuf(basic_stringbuf&& rhs, const allocator_type& a); // C++20 // [stringbuf.assign] Assign and swap: basic_stringbuf& operator=(const basic_stringbuf&) = delete; basic_stringbuf& operator=(basic_stringbuf&& rhs); void swap(basic_stringbuf& rhs) noexcept(see below); // conditionally noexcept since C++20 // [stringbuf.members] Member functions: allocator_type get_allocator() const noexcept; // C++20 basic_string<char_type, traits_type, allocator_type> str() const; // before C++20 basic_string<char_type, traits_type, allocator_type> str() const &; // C++20 template <class SAlloc> basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20 basic_string<char_type, traits_type, allocator_type> str() &&; // C++20 basic_string_view<char_type, traits_type> view() const noexcept; // C++20 void str(const basic_string<char_type, traits_type, allocator_type>& s); template <class SAlloc> void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20 void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20 template<class T> void str(const T& t); // Since C++26 protected: // [stringbuf.virtuals] Overridden virtual functions: virtual int_type underflow(); virtual int_type pbackfail(int_type c = traits_type::eof()); virtual int_type overflow (int_type c = traits_type::eof()); virtual basic_streambuf<char_type, traits_type>* setbuf(char_type*, streamsize); virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); }; // [stringbuf.assign] non member swap template <class charT, class traits, class Allocator> void swap(basic_stringbuf<charT, traits, Allocator>& x, basic_stringbuf<charT, traits, Allocator>& y); // conditionally noexcept since C++20 typedef basic_stringbuf<char> stringbuf; typedef basic_stringbuf<wchar_t> wstringbuf; // Class template basic_istringstream [istringstream] template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_istringstream : public basic_istream<charT, traits> { public: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef Allocator allocator_type; // [istringstream.cons] Constructors: explicit basic_istringstream(ios_base::openmode which = ios_base::in); // before C++20 basic_istringstream() : basic_istringstream(ios_base::in) {} // C++20 explicit basic_istringstream(ios_base::openmode which); // C++20 explicit basic_istringstream(const basic_string<char_type, traits_type, allocator_type>& s, ios_base::openmode which = ios_base::in); basic_istringstream(ios_base::openmode which, const allocator_type& a); // C++20 explicit basic_istringstream(basic_string<char_type, traits_type, allocator_type>&& s, ios_base::openmode which = ios_base::in); // C++20 template <class SAlloc> basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a) : basic_istringstream(s, ios_base::in, a) {} // C++20 template <class SAlloc> basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which, const allocator_type& a); // C++20 template <class SAlloc> explicit basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which = ios_base::in); // C++20 template<class T> explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in); // Since C++26 template<class T> basic_istringstream(const T& t, const Allocator& a); // Since C++26 template<class T> basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a); // Since C++26 basic_istringstream(const basic_istringstream&) = delete; basic_istringstream(basic_istringstream&& rhs); // [istringstream.assign] Assign and swap: basic_istringstream& operator=(const basic_istringstream&) = delete; basic_istringstream& operator=(basic_istringstream&& rhs); void swap(basic_istringstream& rhs); // [istringstream.members] Member functions: basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const; basic_string<char_type, traits_type, allocator_type> str() const; // before C++20 basic_string<char_type, traits_type, allocator_type> str() const &; // C++20 template <class SAlloc> basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20 basic_string<char_type, traits_type, allocator_type> str() &&; // C++20 basic_string_view<char_type, traits_type> view() const noexcept; // C++20 void str(const basic_string<char_type, traits_type, allocator_type>& s); template <class SAlloc> void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20 void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20 template<class T> void str(const T& t); // Since C++26 }; template <class charT, class traits, class Allocator> void swap(basic_istringstream<charT, traits, Allocator>& x, basic_istringstream<charT, traits, Allocator>& y); typedef basic_istringstream<char> istringstream; typedef basic_istringstream<wchar_t> wistringstream; // Class template basic_ostringstream [ostringstream] template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_ostringstream : public basic_ostream<charT, traits> { public: // types: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef Allocator allocator_type; // [ostringstream.cons] Constructors: explicit basic_ostringstream(ios_base::openmode which = ios_base::out); // before C++20 basic_ostringstream() : basic_ostringstream(ios_base::out) {} // C++20 explicit basic_ostringstream(ios_base::openmode which); // C++20 explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& s, ios_base::openmode which = ios_base::out); basic_ostringstream(ios_base::openmode which, const allocator_type& a); // C++20 explicit basic_ostringstream(basic_string<char_type, traits_type, allocator_type>&& s, ios_base::openmode which = ios_base::out); // C++20 template <class SAlloc> basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a) : basic_ostringstream(s, ios_base::out, a) {} // C++20 template <class SAlloc> basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which, const allocator_type& a); // C++20 template <class SAlloc> explicit basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which = ios_base::out); // C++20 template<class T> explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out); // Since C++26 template<class T> basic_ostringstream(const T& t, const Allocator& a); // Since C++26 template<class T> basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a); // Since C++26 basic_ostringstream(const basic_ostringstream&) = delete; basic_ostringstream(basic_ostringstream&& rhs); // [ostringstream.assign] Assign and swap: basic_ostringstream& operator=(const basic_ostringstream&) = delete; basic_ostringstream& operator=(basic_ostringstream&& rhs); void swap(basic_ostringstream& rhs); // [ostringstream.members] Member functions: basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const; basic_string<char_type, traits_type, allocator_type> str() const; // before C++20 basic_string<char_type, traits_type, allocator_type> str() const &; // C++20 template <class SAlloc> basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20 basic_string<char_type, traits_type, allocator_type> str() &&; // C++20 basic_string_view<char_type, traits_type> view() const noexcept; // C++20 void str(const basic_string<char_type, traits_type, allocator_type>& s); template <class SAlloc> void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20 void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20 template<class T> void str(const T& t); // Since C++26 }; template <class charT, class traits, class Allocator> void swap(basic_ostringstream<charT, traits, Allocator>& x, basic_ostringstream<charT, traits, Allocator>& y); typedef basic_ostringstream<char> ostringstream; typedef basic_ostringstream<wchar_t> wostringstream; // Class template basic_stringstream [stringstream] template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_stringstream : public basic_iostream<charT, traits> { public: // types: typedef charT char_type; typedef traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef Allocator allocator_type; // [stringstream.cons] constructors explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20 basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {} // C++20 explicit basic_stringstream(ios_base::openmode which); // C++20 explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& s, ios_base::openmode which = ios_base::out | ios_base::in); basic_stringstream(ios_base::openmode which, const allocator_type& a); // C++20 explicit basic_stringstream(basic_string<char_type, traits_type, allocator_type>&& s, ios_base::openmode which = ios_base::out | ios_base::in); // C++20 template <class SAlloc> basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a) : basic_stringstream(s, ios_base::out | ios_base::in, a) {} // C++20 template <class SAlloc> basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which, const allocator_type& a); // C++20 template <class SAlloc> explicit basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s, ios_base::openmode which = ios_base::out | ios_base::in); // C++20 template<class T> explicit basic_stringstream(const T& t, ios_base::openmode which = ios_base::out | ios_base::in); // Since C++26 template<class T> basic_stringstream(const T& t, const Allocator& a); // Since C++26 template<class T> basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a); // Since C++26 basic_stringstream(const basic_stringstream&) = delete; basic_stringstream(basic_stringstream&& rhs); // [stringstream.assign] Assign and swap: basic_stringstream& operator=(const basic_stringstream&) = delete; basic_stringstream& operator=(basic_stringstream&& rhs); void swap(basic_stringstream& rhs); // [stringstream.members] Member functions: basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const; basic_string<char_type, traits_type, allocator_type> str() const; // before C++20 basic_string<char_type, traits_type, allocator_type> str() const &; // C++20 template <class SAlloc> basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const; // C++20 basic_string<char_type, traits_type, allocator_type> str() &&; // C++20 basic_string_view<char_type, traits_type> view() const noexcept; // C++20 void str(const basic_string<char_type, traits_type, allocator_type>& s); template <class SAlloc> void str(const basic_string<char_type, traits_type, SAlloc>& s); // C++20 void str(basic_string<char_type, traits_type, allocator_type>&& s); // C++20 template<class T> void str(const T& t); // Since C++26 }; template <class charT, class traits, class Allocator> void swap(basic_stringstream<charT, traits, Allocator>& x, basic_stringstream<charT, traits, Allocator>& y); typedef basic_stringstream<char> stringstream; typedef basic_stringstream<wchar_t> wstringstream; } // std */ // clang-format on #include <__config> #include <__fwd/sstream.h> #include <__ostream/basic_ostream.h> #include <__type_traits/is_convertible.h> #include <__utility/swap.h> #include <istream> #include <string> #include <string_view> #include <version> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> _LIBCPP_BEGIN_NAMESPACE_STD // Class template basic_stringbuf [stringbuf] template <class _CharT, class _Traits, class _Allocator> class _LIBCPP_TEMPLATE_VIS basic_stringbuf : public basic_streambuf<_CharT, _Traits> { … }; template <class _CharT, class _Traits, class _Allocator> _LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__move_init(basic_stringbuf&& __rhs) { … } template <class _CharT, class _Traits, class _Allocator> basic_stringbuf<_CharT, _Traits, _Allocator>& basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs) { … } template <class _CharT, class _Traits, class _Allocator> void basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs) #if _LIBCPP_STD_VER >= 20 noexcept(allocator_traits<_Allocator>::propagate_on_container_swap::value || allocator_traits<_Allocator>::is_always_equal::value) #endif { … } template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI void swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y) #if _LIBCPP_STD_VER >= 20 noexcept(noexcept(__x.swap(__y))) #endif { … } #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY) template <class _CharT, class _Traits, class _Allocator> basic_string<_CharT, _Traits, _Allocator> basic_stringbuf<_CharT, _Traits, _Allocator>::str() const { if (__mode_ & ios_base::out) { if (__hm_ < this->pptr()) __hm_ = this->pptr(); return string_type(this->pbase(), __hm_, __str_.get_allocator()); } else if (__mode_ & ios_base::in) return string_type(this->eback(), this->egptr(), __str_.get_allocator()); return string_type(__str_.get_allocator()); } #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY) template <class _CharT, class _Traits, class _Allocator> _LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__init_buf_ptrs() { … } #if _LIBCPP_STD_VER >= 20 template <class _CharT, class _Traits, class _Allocator> _LIBCPP_HIDE_FROM_ABI basic_string_view<_CharT, _Traits> basic_stringbuf<_CharT, _Traits, _Allocator>::view() const noexcept { … } #endif // _LIBCPP_STD_VER >= 20 template <class _CharT, class _Traits, class _Allocator> typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type basic_stringbuf<_CharT, _Traits, _Allocator>::underflow() { … } template <class _CharT, class _Traits, class _Allocator> typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type basic_stringbuf<_CharT, _Traits, _Allocator>::pbackfail(int_type __c) { … } template <class _CharT, class _Traits, class _Allocator> typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c) { … } template <class _CharT, class _Traits, class _Allocator> typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type basic_stringbuf<_CharT, _Traits, _Allocator>::seekoff( off_type __off, ios_base::seekdir __way, ios_base::openmode __wch) { … } // Class template basic_istringstream [istringstream] template <class _CharT, class _Traits, class _Allocator> class _LIBCPP_TEMPLATE_VIS basic_istringstream : public basic_istream<_CharT, _Traits> { … }; template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI void swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, basic_istringstream<_CharT, _Traits, _Allocator>& __y) { … } // Class template basic_ostringstream [ostringstream] template <class _CharT, class _Traits, class _Allocator> class _LIBCPP_TEMPLATE_VIS basic_ostringstream : public basic_ostream<_CharT, _Traits> { … }; template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI void swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, basic_ostringstream<_CharT, _Traits, _Allocator>& __y) { … } // Class template basic_stringstream [stringstream] template <class _CharT, class _Traits, class _Allocator> class _LIBCPP_TEMPLATE_VIS basic_stringstream : public basic_iostream<_CharT, _Traits> { … }; template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI void swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, basic_stringstream<_CharT, _Traits, _Allocator>& __y) { … } #if _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_stringbuf<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_stringstream<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostringstream<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istringstream<char>; #endif _LIBCPP_END_NAMESPACE_STD _LIBCPP_POP_MACROS #if _LIBCPP_STD_VER <= 20 && !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) # include <ostream> # include <type_traits> #endif #endif // _LIBCPP_SSTREAM
Codebase Browser
chromium