folly::io::QueueAppender Class Reference

#include <Cursor.h>

Inheritance diagram for folly::io::QueueAppender:

Public Member Functions
	QueueAppender (IOBufQueue *queue, std::size_t growth)
void	reset (IOBufQueue *queue, std::size_t growth)
uint8_t *	writableData ()
size_t	length ()
void	append (size_t n)
void	ensure (size_t n)
template<class T >
std::enable_if< std::is_arithmetic< T >::value >::type	write (T value)
size_t	pushAtMost (const uint8_t *buf, size_t len)
void	insert (std::unique_ptr< folly::IOBuf > buf)
void	insert (const folly::IOBuf &buf)
Public Member Functions inherited from folly::io::detail::Writable< QueueAppender >
std::enable_if< std::is_arithmetic< T >::value >::type	write (T value)
void	writeBE (T value)
void	writeLE (T value)
void	push (const uint8_t *buf, size_t len)
void	push (ByteRange buf)
void	push (Cursor cursor, size_t len)
size_t	pushAtMost (ByteRange buf)
size_t	pushAtMost (Cursor cursor, size_t len)

Private Member Functions
FOLLY_NOINLINE void	ensureSlow (size_t n)
template<class T >
std::enable_if< std::is_arithmetic< T >::value >::type FOLLY_NOINLINE	writeSlow (T value)

Private Attributes
folly::IOBufQueue::WritableRangeCache	queueCache_ {nullptr}
size_t	growth_ {0}

Detailed Description

Definition at line 1101 of file Cursor.h.

Constructor & Destructor Documentation

folly::io::QueueAppender::QueueAppender ( IOBufQueue *  queue, std::size_t  growth  )

inline

Create an Appender that writes to a IOBufQueue. When we allocate space in the queue, we grow no more than growth bytes at once (unless you call ensure() with a bigger value yourself).

Definition at line 1108 of file Cursor.h.

      : queueCache_(queue), growth_(growth) {}

Member Function Documentation

void folly::io::QueueAppender::append ( size_t  n )

inline

Definition at line 1124 of file Cursor.h.

Referenced by TEST_F().

                        {
    queueCache_.append(n);
  }

void folly::io::QueueAppender::ensure ( size_t  n )

inline

Definition at line 1130 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::length().

Referenced by TEST_F().

                        {
    if (length() < n) {
      ensureSlow(n);
    }
  }

FOLLY_NOINLINE void folly::io::QueueAppender::ensureSlow ( size_t  n )

inlineprivate

Definition at line 1183 of file Cursor.h.

References FOLLY_NOINLINE, type, and value.

                                           {
    queueCache_.queue()->preallocate(n, growth_);
    queueCache_.fillCache();
  }

void folly::io::QueueAppender::insert ( std::unique_ptr< folly::IOBuf >  buf )

inline

Definition at line 1169 of file Cursor.h.

References folly::gen::move.

Referenced by BENCHMARK(), and proxygen::compress::QPACKScheme::encode().

                                             {
    if (buf) {
      queueCache_.queue()->append(std::move(buf), true);
    }
  }

void folly::io::QueueAppender::insert ( const folly::IOBuf &  buf )

inline

Definition at line 1175 of file Cursor.h.

References folly::IOBuf::clone().

                                     {
    insert(buf.clone());
  }

size_t folly::io::QueueAppender::length ( )

inline

Definition at line 1120 of file Cursor.h.

Referenced by TEST_F().

                  {
    return queueCache_.length();
  }

size_t folly::io::QueueAppender::pushAtMost ( const uint8_t *  buf, size_t  len  )

inline

Definition at line 1148 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::length(), and min.

                                                    {
    // Fill the current buffer
    const size_t copyLength = std::min(len, length());
    if (copyLength != 0) {
      memcpy(writableData(), buf, copyLength);
      queueCache_.appendUnsafe(copyLength);
      buf += copyLength;
    }
    size_t remaining = len - copyLength;
    // Allocate more buffers as necessary
    while (remaining != 0) {
      auto p = queueCache_.queue()->preallocate(
          std::min(remaining, growth_), growth_, remaining);
      memcpy(p.first, buf, p.second);
      queueCache_.queue()->postallocate(p.second);
      buf += p.second;
      remaining -= p.second;
    }
    return len;
  }

void folly::io::QueueAppender::reset ( IOBufQueue *  queue, std::size_t  growth  )

inline

Definition at line 1111 of file Cursor.h.

                                                  {
    queueCache_.reset(queue);
    growth_ = growth;
  }

uint8_t* folly::io::QueueAppender::writableData ( )

inline

Definition at line 1116 of file Cursor.h.

                          {
    return queueCache_.writableData();
  }

template<class T >

std::enable_if<std::is_arithmetic<T>::value>::type folly::io::QueueAppender::write ( T  value )

inline

Definition at line 1137 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::length(), folly::storeUnaligned(), folly::T, and folly::value().

Referenced by folly::bser::bserEncode(), folly::bser::bserEncodeArray(), folly::bser::bserEncodeArraySimple(), folly::bser::bserEncodeInt(), folly::bser::bserEncodeObject(), folly::bser::bserEncodeString(), and runArithmeticBench().

                                                                     {
    // We can't fail.
    if (length() >= sizeof(T)) {
      storeUnaligned(queueCache_.writableData(), value);
      queueCache_.appendUnsafe(sizeof(T));
    } else {
      writeSlow<T>(value);
    }
  }

template<class T >

std::enable_if<std::is_arithmetic<T>::value>::type FOLLY_NOINLINE folly::io::QueueAppender::writeSlow ( T  value )

inlineprivate

Definition at line 1190 of file Cursor.h.

References folly::storeUnaligned(), folly::T, and folly::value().

                     {
    queueCache_.queue()->preallocate(sizeof(T), growth_);
    queueCache_.fillCache();

    storeUnaligned(queueCache_.writableData(), value);
    queueCache_.appendUnsafe(sizeof(T));
  }

Member Data Documentation

size_t folly::io::QueueAppender::growth_ {0}

private

Definition at line 1181 of file Cursor.h.

folly::IOBufQueue::WritableRangeCache folly::io::QueueAppender::queueCache_ {nullptr}

private

Definition at line 1180 of file Cursor.h.

---

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

• proxygen/folly/folly/io/Cursor.h