• Log in

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

namespace std{template<class CharT,class Traits= char_traits<CharT>>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<CharT>(), which){}explicit basic_spanbuf(std::span<CharT> 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 setstd::span<CharT> span()constnoexcept;void span(std::span<CharT> 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 onlystd::span<CharT> buf;// exposition only}; template<class CharT,class Traits>void swap(basic_spanbuf<CharT, Traits>& x,              basic_spanbuf<CharT, Traits>& y);}

namespace std{template<class CharT,class Traits= char_traits<CharT>>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; // constructorsexplicit basic_ispanstream(std::span<CharT> s,      ios_base::openmode which= ios_base::in);    basic_ispanstream(const basic_ispanstream&)= delete;    basic_ispanstream(basic_ispanstream&& rhs);template<class ROS>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()constnoexcept;std::span<const CharT> span()constnoexcept;void span(std::span<CharT> s)noexcept;template<class ROS>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);}

namespace std{template<class CharT,class Traits= char_traits<CharT>>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; // constructorsexplicit basic_ospanstream(std::span<CharT> 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()constnoexcept;std::span<CharT> span()constnoexcept;void span(std::span<CharT> 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);}

namespace std{template<class CharT,class Traits= char_traits<CharT>>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; // constructorsexplicit basic_spanstream(std::span<CharT> 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()constnoexcept;std::span<CharT> span()constnoexcept;void span(std::span<CharT> 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);}