fc::buffered_ostream Class Reference

#include <buffered_iostream.hpp>

Inheritance diagram for fc::buffered_ostream:

Collaboration diagram for fc::buffered_ostream:

Public Member Functions
	buffered_ostream (ostream_ptr o, size_t bufsize=4096)
	buffered_ostream (buffered_ostream &&m)
	~buffered_ostream ()
buffered_ostream &	operator= (buffered_ostream &&m)
virtual size_t	writesome (const char *buf, size_t len)
virtual size_t	writesome (const std::shared_ptr< const char > &buf, size_t len, size_t offset)
virtual void	close ()
virtual void	flush ()

Detailed Description

Definition at line 52 of file buffered_iostream.hpp.

Constructor & Destructor Documentation

buffered_ostream() [1/2]

fc::buffered_ostream::buffered_ostream	(	ostream_ptr	o,
		size_t	bufsize = 4096 )

Definition at line 153 of file buffered_iostream.cpp.

    :my( new detail::buffered_ostream_impl( fc::move(os) ) )
    {
    }

buffered_ostream() [2/2]

fc::buffered_ostream::buffered_ostream

(

buffered_ostream &&

m

)

Definition at line 158 of file buffered_iostream.cpp.

    :my( fc::move(o.my) ){}

~buffered_ostream()

fc::buffered_ostream::~buffered_ostream

(

)

Definition at line 167 of file buffered_iostream.cpp.

{}

Member Function Documentation

close()

void fc::buffered_ostream::close ( )

virtual

Definition at line 202 of file buffered_iostream.cpp.

    {
        flush();
        my->_ostr->close();
    }

Here is the call graph for this function:

flush()

void fc::buffered_ostream::flush ( )

virtual

Definition at line 181 of file buffered_iostream.cpp.

    {
#ifndef NDEBUG
        // This code was written with the assumption that you'd only be making one call to flush 
        // at a time so it reuses _shared_write_buffer.  If you really need to make concurrent calls to 
        // flush(), you'll need to prevent reusing _shared_write_buffer here
        struct check_buffer_in_use {
          bool& _buffer_in_use;
          check_buffer_in_use(bool& buffer_in_use) : _buffer_in_use(buffer_in_use) { assert(!_buffer_in_use); _buffer_in_use = true; }
          ~check_buffer_in_use() { assert(_buffer_in_use); _buffer_in_use = false; }
        } buffer_in_use_checker(my->_shared_write_buffer_in_use);
#endif
        const size_t write_buffer_size = 2048;
        if (!my->_shared_write_buffer)
          my->_shared_write_buffer.reset(new char[write_buffer_size], [](char* p){ delete[] p; });
 
        while( size_t bytes_from_rdbuf = static_cast<size_t>(my->_rdbuf.sgetn(my->_shared_write_buffer.get(), write_buffer_size)) )
           my->_ostr->write( my->_shared_write_buffer, bytes_from_rdbuf );
        my->_ostr->flush();
    }

Here is the caller graph for this function:

operator=()

buffered_ostream & fc::buffered_ostream::operator=

(

buffered_ostream &&

m

)

Definition at line 161 of file buffered_iostream.cpp.

    {
       my = fc::move(i.my);
       return *this;
    }

writesome() [1/2]

size_t fc::buffered_ostream::writesome ( const char * buf, size_t len )

virtual

This method will return immediately unless the buffer is full, in which case it will flush which may block.

Definition at line 169 of file buffered_iostream.cpp.

    {
        size_t written = static_cast<size_t>(my->_rdbuf.sputn( buf, len ));
        if( written < len ) { flush(); }
        return written + static_cast<size_t>(my->_rdbuf.sputn( buf+written, len-written ));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

writesome() [2/2]

size_t fc::buffered_ostream::writesome ( const std::shared_ptr< const char > & buf, size_t len, size_t offset )

virtual

Definition at line 176 of file buffered_iostream.cpp.

    {
      return writesome(buf.get() + offset, len);
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/io/buffered_iostream.hpp
• libraries/fc/src/io/buffered_iostream.cpp