Function Template write

Overview
Example
Headers
Reference

Overview

The two overloads of the function template write provide a uniform interface for writing a sequence of characters to a Sink or OutputFilter.

Example

The following code illustrates the use of the function write in the definition of an OutputFilter which reverses its controlled sequence.

    #include <algorithm>                      // reverse 
    #include <vector>
    #include <boost/iostreams/concepts.hpp>   // output_filter 
    #include <boost/iostreams/operations.hpp> // write

    using namespace std;
    using namespace boost::io;

    struct reversing_filter : public multichar_output_filter {
        template<typename Sink>
        std::streamsize write(Sink& snk, const char* s, streamsize n)
        {
            data.insert(data.end(), s, s + n);
            return n;
        }
        template<typename Sink>
        void close(Sink& snk)
        {
            std::reverse(data.begin(), data.end());
            boost::iostreams::write(&data[0], (streamsize) data.size());
            data.clear();
        }
        std::vector<char> data;
    };

Headers

<boost/iostreams/operations.hpp>
<boost/iostreams/write.hpp>

Reference

Description

Attempts to write a sequence of characters to a given instance of the template parameter T, returning the number of characters written.

Synopsis

namespace boost { namespace iostreams {
              
template<typename T>     
std::streamsize 
write( T& t, 
       const typename char_type_of<T>::type* s, 
       std::streamsize n );

template<typename T, typename Sink>
std::streamsize 
write( T& t,
       Sink& snk, 
       const typename char_type_of<T>::type* s, 
       std::streamsize n );

} } // End namespace boost::io

Template Parameters

T- For the first overload, a model of Sink. For the second overload, a model of OutputFilter.
Sink- A model of Sink with the same character type as T whose mode refines that of T.

Function Parameters

t- An instance of T
s- A buffer containing characters to write
n- The number of characters to write
snk- An instance of Sink.

Semantics — Device Types

template<typename T>     
std::streamsize
write( T& t, 
       const typename char_type_of<T>::type* s,
       std::streamsize n );

The semantics of write depends on the category of T as follows:

category_of<T>::typesemantics
convertible to ostream_tag returns t.rdbuf()->sputn(s, n)
convertible to streambuf_tag but not to ostream_tag returns t.sputn(s, n)
otherwise returns t.write(s, n)

Semantics — Filter Types

template<typename T, typename Sink>
std::streamsize
write( T& t, 
       Sink& snk, 
       const typename char_type_of<T>::type* s,
       std::streamsize n );

The semantics of write depends on the category of T as follows:

category_of<T>::typesemantics
convertible to multichar_tag returns t.write(snk, s, n)
otherwise Attempts to write n characters from s by invoking t.put(snk, s[m]) for each value m in the interval [0, n), halting if put returns false. Returns the number of characters written.