Standard library header  (C++23) (original) (raw)

This header is part of the Input/Output library.

[edit] Synopsis

namespace std { template<class CharT, class Traits = char_traits> class basic_spanbuf;   using spanbuf = basic_spanbuf; using wspanbuf = basic_spanbuf;   template<class CharT, class Traits = char_traits> class basic_ispanstream;   using ispanstream = basic_ispanstream; using wispanstream = basic_ispanstream;   template<class CharT, class Traits = char_traits> class basic_ospanstream;   using ospanstream = basic_ospanstream; using wospanstream = basic_ospanstream;   template<class CharT, class Traits = char_traits> class basic_spanstream;   using spanstream = basic_spanstream; using wspanstream = basic_spanstream; }

[edit] Class template std::basic_spanbuf

namespace std { template<class CharT, class Traits = char_traits> class basic_spanbuf : public basic_streambuf<CharT, Traits> { public: using char_type = CharT; using int_type = typename Traits::int_type; using pos_type = typename Traits::pos_type; using off_type = typename Traits::off_type; using traits_type = Traits;   // constructors basic_spanbuf() : basic_spanbuf(ios_base::in | ios_base::out) {} explicit basic_spanbuf(ios_base::openmode which) : basic_spanbuf(std::span(), which) {} explicit basic_spanbuf( std::span s, ios_base::openmode which = ios_base::in | ios_base::out); basic_spanbuf(const basic_spanbuf&) = delete; basic_spanbuf(basic_spanbuf&& rhs);   // assign and swap basic_spanbuf& operator=(const basic_spanbuf&) = delete; basic_spanbuf& operator=(basic_spanbuf&& rhs); void swap(basic_spanbuf& rhs);   // get and set std::span span() const noexcept; void span(std::span s) noexcept;   protected: // overridden virtual functions basic_streambuf<CharT, Traits>* setbuf(CharT*, streamsize) override; pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out) override; pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out) override;   private: ios_base::openmode mode; // exposition only std::span buf; // exposition only };   template<class CharT, class Traits> void swap(basic_spanbuf<CharT, Traits>& x, basic_spanbuf<CharT, Traits>& y); }

[edit] Class template std::basic_ispanstream

namespace std { template<class CharT, class Traits = char_traits> class basic_ispanstream : public basic_istream<CharT, Traits> { public: using char_type = CharT; using int_type = typename Traits::int_type; using pos_type = typename Traits::pos_type; using off_type = typename Traits::off_type; using traits_type = Traits;   // constructors explicit basic_ispanstream( std::span s, ios_base::openmode which = ios_base::in); basic_ispanstream(const basic_ispanstream&) = delete; basic_ispanstream(basic_ispanstream&& rhs); template explicit basic_ispanstream(ROS&& s);   // assign and swap basic_ispanstream& operator=(const basic_ispanstream&) = delete; basic_ispanstream& operator=(basic_ispanstream&& rhs); void swap(basic_ispanstream& rhs);   // members basic_spanbuf<CharT, Traits>* rdbuf() const noexcept; std::span span() const noexcept; void span(std::span s) noexcept; template void span(ROS&& s) noexcept;   private: basic_spanbuf<CharT, Traits> sb; // exposition only };   template<class CharT, class Traits> void swap(basic_ispanstream<CharT, Traits>& x, basic_ispanstream<CharT, Traits>& y); }

[edit] Class template std::basic_ospanstream

namespace std { template<class CharT, class Traits = char_traits> class basic_ospanstream : public basic_ostream<CharT, Traits> { public: using char_type = CharT; using int_type = typename Traits::int_type; using pos_type = typename Traits::pos_type; using off_type = typename Traits::off_type; using traits_type = Traits;   // constructors explicit basic_ospanstream( std::span s, ios_base::openmode which = ios_base::out); basic_ospanstream(const basic_ospanstream&) = delete; basic_ospanstream(basic_ospanstream&& rhs);   // assign and swap basic_ospanstream& operator=(const basic_ospanstream&) = delete; basic_ospanstream& operator=(basic_ospanstream&& rhs); void swap(basic_ospanstream& rhs);   // members basic_spanbuf<CharT, Traits>* rdbuf() const noexcept; std::span span() const noexcept; void span(std::span s) noexcept;   private: basic_spanbuf<CharT, Traits> sb; // exposition only };   template<class CharT, class Traits> void swap(basic_ospanstream<CharT, Traits>& x, basic_ospanstream<CharT, Traits>& y); }

[edit] Class template std::basic_spanstream

namespace std { template<class CharT, class Traits = char_traits> class basic_spanstream : public basic_iostream<CharT, Traits> { public: using char_type = CharT; using int_type = typename Traits::int_type; using pos_type = typename Traits::pos_type; using off_type = typename Traits::off_type; using traits_type = Traits;   // constructors explicit basic_spanstream( std::span s, ios_base::openmode which = ios_base::out | ios_base::in); basic_spanstream(const basic_spanstream&) = delete; basic_spanstream(basic_spanstream&& rhs);   // assign and swap basic_spanstream& operator=(const basic_spanstream&) = delete; basic_spanstream& operator=(basic_spanstream&& rhs); void swap(basic_spanstream& rhs);   // members basic_spanbuf<CharT, Traits>* rdbuf() const noexcept; std::span span() const noexcept; void span(std::span s) noexcept;   private: basic_spanbuf<CharT, Traits> sb; // exposition only };   template<class CharT, class Traits> void swap(basic_spanstream<CharT, Traits>& x, basic_spanstream<CharT, Traits>& y); }