BufferedWriter< TBufferSize > Class Template Reference

#include <buffered_writer.h>

Inheritance diagram for BufferedWriter< TBufferSize >:

Collaboration diagram for BufferedWriter< TBufferSize >:

Public Member Functions
size_t	write (const char *buffer, size_t count) override
size_t	flush () override

Protected Member Functions
virtual size_t	writeInternal (const char *buffer, size_t count)=0

Private Attributes
char	m_buffer [TBufferSize]
size_t	m_bytesUsed = 0

Detailed Description

template<int TBufferSize>
class BufferedWriter< TBufferSize >

Definition at line 12 of file buffered_writer.h.

Member Function Documentation

flush()

template<int TBufferSize>

size_t BufferedWriter< TBufferSize >::flush ( )

inlineoverridevirtual

Implements Writer.

Definition at line 47 of file buffered_writer.h.

                            {
        size_t bytesToWrite = m_bytesUsed;
        
        if (bytesToWrite > 0) {
            m_bytesUsed = 0;
            return writeInternal(m_buffer, bytesToWrite);
        } else {
            return 0;
        }
    }

Referenced by BufferedWriter< TBufferSize >::write().

Here is the call graph for this function:

Here is the caller graph for this function:

write()

template<int TBufferSize>

size_t BufferedWriter< TBufferSize >::write ( const char *  buffer, size_t  count  )

inlineoverridevirtual

Implements Writer.

Definition at line 14 of file buffered_writer.h.

                                                            {
        size_t bytesFlushed = 0;
 
        while (count) {
            if (m_bytesUsed == 0 && count >= TBufferSize) {
                // special case: write-thru, skip the copy
                bytesFlushed += writeInternal(buffer, count);
                count = 0;
            } else if (m_bytesUsed + count < TBufferSize) {
                // Write that will fit in the buffer, just copy to intermediate buffer
                memcpy(m_buffer + m_bytesUsed, buffer, count);
                m_bytesUsed += count;
                count = 0;
            } else {
                // Need to write partial, then flush buffer
                size_t bytesToWrite = TBufferSize - m_bytesUsed;
                // Copy this block in to place
                memcpy(m_buffer + m_bytesUsed, buffer, bytesToWrite);
                m_bytesUsed += bytesToWrite;
 
                // Flush to underlying
                bytesFlushed += flush();
                // Step the read pointer ahead
                buffer += bytesToWrite;
                // Decrement remaining bytes
                count -= bytesToWrite;
            }
        }
 
        return bytesFlushed;
    }

Here is the call graph for this function:

writeInternal()

template<int TBufferSize>

virtual size_t BufferedWriter< TBufferSize >::writeInternal ( const char *  buffer, size_t  count  )

protectedpure virtual

Referenced by BufferedWriter< TBufferSize >::flush(), and BufferedWriter< TBufferSize >::write().

Here is the caller graph for this function:

Field Documentation

m_buffer

template<int TBufferSize>

char BufferedWriter< TBufferSize >::m_buffer[TBufferSize]

private

Definition at line 62 of file buffered_writer.h.

Referenced by BufferedWriter< TBufferSize >::flush(), and BufferedWriter< TBufferSize >::write().

m_bytesUsed

template<int TBufferSize>

size_t BufferedWriter< TBufferSize >::m_bytesUsed = 0

private

Definition at line 63 of file buffered_writer.h.

Referenced by BufferedWriter< TBufferSize >::flush(), and BufferedWriter< TBufferSize >::write().

---

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

• controllers/system/buffered_writer.h