folly::io::Appender Class Reference

#include <Cursor.h>

Inheritance diagram for folly::io::Appender:

Public Member Functions
	Appender (IOBuf *buf, std::size_t growth)
uint8_t *	writableData ()
size_t	length () const
void	append (size_t n)
void	ensure (std::size_t n)
size_t	pushAtMost (const uint8_t *buf, size_t len)
void	printf (FOLLY_PRINTF_FORMAT const char *fmt,...) FOLLY_PRINTF_FORMAT_ATTR(2
void void	vprintf (const char *fmt, va_list ap)
void	operator() (StringPiece sp)
Public Member Functions inherited from folly::io::detail::Writable< Appender >
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
bool	tryGrowChain ()

Private Attributes
IOBuf *	buffer_
IOBuf *	crtBuf_
std::size_t	growth_

Detailed Description

Append to the end of a buffer chain, growing the chain (by allocating new buffers) in increments of at least growth bytes every time. Won't grow (and push() and ensure() will throw) if growth == 0.

TODO(tudorb): add a flavor of Appender that reallocates one IOBuf instead of chaining.

Definition at line 969 of file Cursor.h.

Constructor & Destructor Documentation

folly::io::Appender::Appender ( IOBuf *  buf, std::size_t  growth  )

inline

Definition at line 971 of file Cursor.h.

      : buffer_(buf), crtBuf_(buf->prev()), growth_(growth) {}

Member Function Documentation

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

inline

Mark n bytes (must be <= length()) as appended, as per the IOBuf::append() method.

Definition at line 986 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtBuf_.

Referenced by vprintf().

                        {
    crtBuf_->append(n);
  }

void folly::io::Appender::ensure ( std::size_t  n )

inline

Ensure at least n contiguous bytes available to write. Postcondition: length() >= n.

Definition at line 994 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::buffer_, folly::IOBuf::create(), folly::io::detail::CursorBase< Derived, BufType >::crtBuf_, folly::io::detail::CursorBase< Derived, BufType >::length(), LIKELY, and max.

Referenced by vprintf().

                           {
    if (LIKELY(length() >= n)) {
      return;
    }

    // Waste the rest of the current buffer and allocate a new one.
    // Don't make it too small, either.
    if (growth_ == 0) {
      throw_exception<std::out_of_range>("can't grow buffer chain");
    }

    n = std::max(n, growth_);
    buffer_->prependChain(IOBuf::create(n));
    crtBuf_ = buffer_->prev();
  }

size_t folly::io::Appender::length ( ) const

inline

Definition at line 978 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtBuf_.

Referenced by vprintf().

                        {
    return crtBuf_->tailroom();
  }

void folly::io::Appender::operator() ( StringPiece  sp )

inline

Definition at line 1080 of file Cursor.h.

                                  {
    push(ByteRange(sp));
  }

void folly::io::Appender::printf	(	FOLLY_PRINTF_FORMAT const char *	fmt,
			...
	)

Definition at line 26 of file Cursor.cpp.

References vprintf().

Referenced by TEST().

                                          {
  va_list ap;
  va_start(ap, fmt);
  vprintf(fmt, ap);
  va_end(ap);
}

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

inline

Definition at line 1011 of file Cursor.h.

References append(), FOLLY_PRINTF_FORMAT, FOLLY_PRINTF_FORMAT_ATTR, folly::io::detail::CursorBase< Derived, BufType >::length(), LIKELY, and UNLIKELY.

                                                    {
    // We have to explicitly check for an input length of 0.
    // We support buf being nullptr in this case, but we need to avoid calling
    // memcpy() with a null source pointer, since that is undefined behavior
    // even if the length is 0.
    if (len == 0) {
      return 0;
    }

    // If the length of this buffer is 0 try growing it.
    // Otherwise on the first iteration of the following loop memcpy is called
    // with a null source pointer.
    if (UNLIKELY(length() == 0 && !tryGrowChain())) {
      return 0;
    }

    size_t copied = 0;
    for (;;) {
      // Fast path: it all fits in one buffer.
      size_t available = length();
      if (LIKELY(available >= len)) {
        memcpy(writableData(), buf, len);
        append(len);
        return copied + len;
      }

      memcpy(writableData(), buf, available);
      append(available);
      copied += available;
      if (UNLIKELY(!tryGrowChain())) {
        return copied;
      }
      buf += available;
      len -= available;
    }
  }

bool folly::io::Appender::tryGrowChain ( )

inlineprivate

Definition at line 1085 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::buffer_, folly::IOBuf::create(), and folly::io::detail::CursorBase< Derived, BufType >::crtBuf_.

                      {
    assert(crtBuf_->next() == buffer_);
    if (growth_ == 0) {
      return false;
    }

    buffer_->prependChain(IOBuf::create(growth_));
    crtBuf_ = buffer_->prev();
    return true;
  }

void folly::io::Appender::vprintf	(	const char *	fmt,
		va_list	ap
	)

Definition at line 33 of file Cursor.cpp.

References append(), ensure(), length(), SCOPE_EXIT, and writableData().

Referenced by printf().

                                                  {
  // Make a copy of ap in case we need to retry.
  // We use ap on the first attempt, so it always gets advanced
  // passed the used arguments.  We'll only use apCopy if we need to retry.
  va_list apCopy;
  va_copy(apCopy, ap);
  SCOPE_EXIT {
    va_end(apCopy);
  };

  // First try writing into our available data space.
  int ret =
      vsnprintf(reinterpret_cast<char*>(writableData()), length(), fmt, ap);
  if (ret < 0) {
    throw std::runtime_error("error formatting printf() data");
  }
  auto len = size_t(ret);
  // vsnprintf() returns the number of characters that would be printed,
  // not including the terminating nul.
  if (len < length()) {
    // All of the data was successfully written.
    append(len);
    return;
  }

  // There wasn't enough room for the data.
  // Allocate more room, and then retry.
  ensure(len + 1);
  ret =
      vsnprintf(reinterpret_cast<char*>(writableData()), length(), fmt, apCopy);
  if (ret < 0) {
    throw std::runtime_error("error formatting printf() data");
  }
  len = size_t(ret);
  if (len >= length()) {
    // This shouldn't ever happen.
    throw std::runtime_error(
        "unexpectedly out of buffer space on second "
        "vsnprintf() attmept");
  }
  append(len);
}

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

inline

Definition at line 974 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtBuf_.

Referenced by vprintf().

                          {
    return crtBuf_->writableTail();
  }

Member Data Documentation

IOBuf* folly::io::Appender::buffer_

private

Definition at line 1096 of file Cursor.h.

IOBuf* folly::io::Appender::crtBuf_

private

Definition at line 1097 of file Cursor.h.

std::size_t folly::io::Appender::growth_

private

Definition at line 1098 of file Cursor.h.

---

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

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