fc::buffered_istream Class Reference

Reads data from an unbuffered stream and enables peek functionality. More...

#include <buffered_iostream.hpp>

Inheritance diagram for fc::buffered_istream:

Collaboration diagram for fc::buffered_istream:

Public Member Functions
	buffered_istream (istream_ptr is)
	buffered_istream (buffered_istream &&o)
buffered_istream &	operator= (buffered_istream &&i)
virtual	~buffered_istream ()
virtual std::size_t	readsome (char *buf, std::size_t len)
virtual size_t	readsome (const std::shared_ptr< char > &buf, size_t len, size_t offset)
virtual char	peek () const

Detailed Description

Definition at line 16 of file buffered_iostream.hpp.

Constructor & Destructor Documentation

buffered_istream() [1/2]

fc::buffered_istream::buffered_istream

(

istream_ptr

is

)

Definition at line 32 of file buffered_iostream.cpp.

    :my( new detail::buffered_istream_impl( fc::move(is) ) )
    {
       FC_ASSERT( my->_istr != nullptr, " this shouldn't be null" );
    }

buffered_istream() [2/2]

fc::buffered_istream::buffered_istream

(

buffered_istream &&

o

)

Definition at line 38 of file buffered_iostream.cpp.

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

~buffered_istream()

fc::buffered_istream::~buffered_istream ( )

virtual

Definition at line 47 of file buffered_iostream.cpp.

{}

Member Function Documentation

operator=()

buffered_istream & fc::buffered_istream::operator=

(

buffered_istream &&

i

)

Definition at line 41 of file buffered_iostream.cpp.

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

peek()

char fc::buffered_istream::peek ( ) const

virtual

This method may block until at least 1 character is available.

Definition at line 112 of file buffered_iostream.cpp.

    {
       if( my->_rdbuf.size() )
       {
          return my->_rdbuf.sgetc();
       }
 
       char tmp[detail::minimum_read_size];
       size_t bytes_read = my->_istr->readsome( tmp, detail::minimum_read_size );
       my->_rdbuf.sputn( tmp, bytes_read );
 
       if( my->_rdbuf.size() )
       {
          return my->_rdbuf.sgetc();
       }
       FC_THROW_EXCEPTION( assert_exception, 
          "at least one byte should be available, or eof should have been thrown" );
    }

readsome() [1/2]

virtual std::size_t fc::buffered_istream::readsome ( char * buf, std::size_t len )

virtual

read at least 1 byte or throw, if no data is available this method should block cooperatively until data is available or fc::eof_exception is thrown.

Precondition

len > 0

buf != nullptr

Exceptions

fc::eof

if at least 1 byte cannot be read

readsome() [2/2]

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

virtual

Definition at line 75 of file buffered_iostream.cpp.

    {
        size_t bytes_from_rdbuf = static_cast<size_t>(my->_rdbuf.sgetn(buf.get() + offset, len));
        if (bytes_from_rdbuf)
           return bytes_from_rdbuf;
 
 
        if( len > detail::minimum_read_size ) 
           return my->_istr->readsome(buf.get() + offset, len);
 
#ifndef NDEBUG
        // This code was written with the assumption that you'd only be making one call to readsome 
        // at a time so it reuses _shared_read_buffer.  If you really need to make concurrent calls to 
        // readsome(), you'll need to prevent reusing _shared_read_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_read_buffer_in_use);
#endif
 
        if (!my->_shared_read_buffer)
          my->_shared_read_buffer.reset(new char[detail::minimum_read_size], [](char* p){ delete[] p; });
        size_t bytes_read = my->_istr->readsome( my->_shared_read_buffer, detail::minimum_read_size, 0 );
 
        size_t bytes_to_deliver_immediately = std::min<size_t>(bytes_read,len);
 
        memcpy( buf.get() + offset, my->_shared_read_buffer.get(), bytes_to_deliver_immediately );
        
        if( bytes_read > len )
        {
           my->_rdbuf.sputn( my->_shared_read_buffer.get() + len, bytes_read - len );
        }
 
        return bytes_to_deliver_immediately;
    }

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