folly::io::detail::CursorBase< Derived, BufType > Class Template Reference

#include <Cursor.h>

Public Member Functions
	CursorBase (BufType *buf)
template<class OtherDerived , class OtherBuf >
	CursorBase (const CursorBase< OtherDerived, OtherBuf > &cursor)
void	reset (BufType *buf)
size_t	getCurrentPosition () const
const uint8_t *	data () const
size_t	length () const
size_t	totalLength () const
bool	canAdvance (size_t amount) const
bool	isAtEnd () const
void	advanceToEnd ()
Derived &	operator+= (size_t offset)
Derived	operator+ (size_t offset) const
Derived &	operator-= (size_t offset)
Derived	operator- (size_t offset) const
bool	operator== (const Derived &other) const
bool	operator!= (const Derived &other) const
template<class T >
std::enable_if< std::is_arithmetic< T >::value, bool >::type	tryRead (T &val)
template<class T >
bool	tryReadBE (T &val)
template<class T >
bool	tryReadLE (T &val)
template<class T >
T	read ()
template<class T >
T	readBE ()
template<class T >
T	readLE ()
std::string	readFixedString (size_t len)
std::string	readTerminatedString (char termChar= '\0', size_t maxLength=std::numeric_limits< size_t >::max())
template<typename Predicate >
std::string	readWhile (const Predicate &predicate)
template<typename Predicate , typename Output >
void	readWhile (const Predicate &predicate, Output &out)
template<typename Predicate >
void	skipWhile (const Predicate &predicate)
size_t	skipAtMost (size_t len)
void	skip (size_t len)
void	skipNoAdvance (size_t len)
size_t	retreatAtMost (size_t len)
void	retreat (size_t len)
size_t	pullAtMost (void *buf, size_t len)
void	pull (void *buf, size_t len)
ByteRange	peekBytes ()
std::pair< const uint8_t *, size_t >	peek ()
void	clone (std::unique_ptr< folly::IOBuf > &buf, size_t len)
void	clone (folly::IOBuf &buf, size_t len)
size_t	cloneAtMost (folly::IOBuf &buf, size_t len)
size_t	cloneAtMost (std::unique_ptr< folly::IOBuf > &buf, size_t len)
size_t	operator- (const CursorBase &other) const
size_t	operator- (const BufType *buf) const

Protected Member Functions
void	dcheckIntegrity () const
	~CursorBase ()
BufType *	head ()
bool	tryAdvanceBuffer ()
bool	tryRetreatBuffer ()
void	advanceBufferIfEmpty ()

Protected Attributes
BufType *	crtBuf_
BufType *	buffer_
const uint8_t *	crtBegin_ {nullptr}
const uint8_t *	crtEnd_ {nullptr}
const uint8_t *	crtPos_ {nullptr}
size_t	absolutePos_ {0}

Private Member Functions
template<class T >
FOLLY_NOINLINE T	readSlow ()
void	readFixedStringSlow (std::string *str, size_t len)
size_t	pullAtMostSlow (void *buf, size_t len)
void	pullSlow (void *buf, size_t len)
size_t	skipAtMostSlow (size_t len)
void	skipSlow (size_t len)
size_t	retreatAtMostSlow (size_t len)
void	retreatSlow (size_t len)
void	advanceDone ()

Friends
template<class D , typename B >
class	CursorBase

Detailed Description

template<class Derived, class BufType>
class folly::io::detail::CursorBase< Derived, BufType >

Definition at line 56 of file Cursor.h.

Constructor & Destructor Documentation

template<class Derived, class BufType>

folly::io::detail::CursorBase< Derived, BufType >::CursorBase ( BufType *  buf )

inlineexplicit

Definition at line 62 of file Cursor.h.

                                    : crtBuf_(buf), buffer_(buf) {
    if (crtBuf_) {
      crtPos_ = crtBegin_ = crtBuf_->data();
      crtEnd_ = crtBuf_->tail();
    }
  }

template<class Derived, class BufType>

template<class OtherDerived , class OtherBuf >

folly::io::detail::CursorBase< Derived, BufType >::CursorBase ( const CursorBase< OtherDerived, OtherBuf > &  cursor )

inlineexplicit

Copy constructor.

This also allows constructing a CursorBase from other derived types. For instance, this allows constructing a Cursor from an RWPrivateCursor.

Definition at line 76 of file Cursor.h.

      : crtBuf_(cursor.crtBuf_),
        buffer_(cursor.buffer_),
        crtBegin_(cursor.crtBegin_),
        crtEnd_(cursor.crtEnd_),
        crtPos_(cursor.crtPos_),
        absolutePos_(cursor.absolutePos_) {}

template<class Derived, class BufType>

folly::io::detail::CursorBase< Derived, BufType >::~CursorBase ( )

inlineprotected

Definition at line 578 of file Cursor.h.

{}

Member Function Documentation

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::advanceBufferIfEmpty ( )

inlineprotected

Definition at line 612 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedStringSlow(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMostSlow().

                              {
    dcheckIntegrity();
    if (crtPos_ == crtEnd_) {
      tryAdvanceBuffer();
    }
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::advanceDone ( )

inlineprivate

Definition at line 716 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer().

{}

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::advanceToEnd ( )

inline

Advances the cursor to the end of the entire IOBuf chain.

Definition at line 185 of file Cursor.h.

Referenced by fizz::EncryptedReadRecordLayer::read(), and TEST().

                      {
    // Simple case, we're already in the last IOBuf.
    if (crtBuf_ == buffer_->prev()) {
      crtPos_ = crtEnd_;
      return;
    }

    auto* nextBuf = crtBuf_->next();
    while (nextBuf != buffer_) {
      absolutePos_ += crtEnd_ - crtBegin_;

      crtBuf_ = nextBuf;
      nextBuf = crtBuf_->next();
      crtBegin_ = crtBuf_->data();
      crtPos_ = crtEnd_ = crtBuf_->tail();

      static_cast<Derived*>(this)->advanceDone();
    }
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::canAdvance ( size_t  amount ) const

inline

Return true if the cursor could advance the specified number of bytes from its current position. This is useful for applications that want to do checked reads instead of catching exceptions and is more efficient than using totalLength as it walks the minimal set of buffers in the chain to determine the result.

Definition at line 142 of file Cursor.h.

                                       {
    const IOBuf* nextBuf = crtBuf_;
    size_t available = length();
    do {
      if (available >= amount) {
        return true;
      }
      amount -= available;
      nextBuf = nextBuf->next();
      available = nextBuf->length();
    } while (nextBuf != buffer_);
    return false;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::clone ( std::unique_ptr< folly::IOBuf > &  buf, size_t  len  )

inline

Definition at line 456 of file Cursor.h.

Referenced by proxygen::HTTP2Codec::parseDataFrameData(), proxygen::SPDYCodec::parseIngress(), and fizz::detail::readBuf().

                                                         {
    if (UNLIKELY(cloneAtMost(buf, len) != len)) {
      throw_exception<std::out_of_range>("underflow");
    }
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::clone ( folly::IOBuf &  buf, size_t  len  )

inline

Definition at line 462 of file Cursor.h.

                                          {
    if (UNLIKELY(cloneAtMost(buf, len) != len)) {
      throw_exception<std::out_of_range>("underflow");
    }
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::cloneAtMost ( folly::IOBuf &  buf, size_t  len  )

inline

Definition at line 468 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::clone(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost().

                                                  {
    // We might be at the end of buffer.
    advanceBufferIfEmpty();

    std::unique_ptr<folly::IOBuf> tmp;
    size_t copied = 0;
    for (int loopCount = 0; true; ++loopCount) {
      // Fast path: it all fits in one buffer.
      size_t available = length();
      if (LIKELY(available >= len)) {
        if (loopCount == 0) {
          crtBuf_->cloneOneInto(buf);
          buf.trimStart(crtPos_ - crtBegin_);
          buf.trimEnd(buf.length() - len);
        } else {
          tmp = crtBuf_->cloneOne();
          tmp->trimStart(crtPos_ - crtBegin_);
          tmp->trimEnd(tmp->length() - len);
          buf.prependChain(std::move(tmp));
        }

        crtPos_ += len;
        advanceBufferIfEmpty();
        return copied + len;
      }

      if (loopCount == 0) {
        crtBuf_->cloneOneInto(buf);
        buf.trimStart(crtPos_ - crtBegin_);
      } else {
        tmp = crtBuf_->cloneOne();
        tmp->trimStart(crtPos_ - crtBegin_);
        buf.prependChain(std::move(tmp));
      }

      copied += available;
      if (UNLIKELY(!tryAdvanceBuffer())) {
        return copied;
      }
      len -= available;
    }
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::cloneAtMost ( std::unique_ptr< folly::IOBuf > &  buf, size_t  len  )

inline

Definition at line 511 of file Cursor.h.

                                                                 {
    if (!buf) {
      buf = std::make_unique<folly::IOBuf>();
    }
    return cloneAtMost(*buf, len);
  }

template<class Derived, class BufType>

const uint8_t* folly::io::detail::CursorBase< Derived, BufType >::data ( ) const

inline

Definition at line 105 of file Cursor.h.

Referenced by proxygen::HPACKDecodeBuffer::decodeLiteral(), proxygen::HPACKDecodeBuffer::peek(), folly::io::detail::CursorBase< Cursor, const IOBuf >::peekBytes(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pull(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::read(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedStringSlow(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRead().

                              {
    dcheckIntegrity();
    return crtPos_;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::dcheckIntegrity ( ) const

inlineprotected

Definition at line 570 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceBufferIfEmpty(), folly::io::detail::CursorBase< Cursor, const IOBuf >::data(), folly::io::RWCursor< access >::gatherAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::getCurrentPosition(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::length(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pull(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreat(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skip(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMost(), and folly::io::RWCursor< access >::writableData().

                               {
    DCHECK(crtBegin_ <= crtPos_ && crtPos_ <= crtEnd_);
    DCHECK(crtBuf_ == nullptr || crtBegin_ == crtBuf_->data());
    DCHECK(
        crtBuf_ == nullptr ||
        (std::size_t)(crtEnd_ - crtBegin_) == crtBuf_->length());
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::getCurrentPosition ( ) const

inline

Get the current Cursor position relative to the head of IOBuf chain.

Definition at line 100 of file Cursor.h.

                                    {
    dcheckIntegrity();
    return (crtPos_ - crtBegin_) + absolutePos_;
  }

template<class Derived, class BufType>

BufType* folly::io::detail::CursorBase< Derived, BufType >::head ( )

inlineprotected

Definition at line 580 of file Cursor.h.

Referenced by folly::io::RWCursor< access >::gather().

                  {
    return buffer_;
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::isAtEnd ( ) const

inline

Definition at line 159 of file Cursor.h.

Referenced by fizz::decode(), and fizz::transformBufferBlocks().

                       {
    dcheckIntegrity();
    // Check for the simple cases first.
    if (crtPos_ != crtEnd_) {
      return false;
    }
    if (crtBuf_ == buffer_->prev()) {
      return true;
    }
    // We are at the end of a buffer, but it isn't the last buffer.
    // We might still be at the end if the remaining buffers in the chain are
    // empty.
    const IOBuf* buf = crtBuf_->next();
    ;
    while (buf != buffer_) {
      if (buf->length() > 0) {
        return false;
      }
      buf = buf->next();
    }
    return true;
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::length ( ) const

inline

Return the remaining space available in the current IOBuf.

May return 0 if the cursor is at the end of an IOBuf. Use peekBytes() instead if you want to avoid this. peekBytes() will advance to the next non-empty IOBuf (up to the end of the chain) if the cursor is currently pointing at the end of a buffer.

Definition at line 118 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::canAdvance(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), proxygen::HPACKDecodeBuffer::decodeLiteral(), folly::io::Appender::ensure(), folly::io::QueueAppender::ensure(), folly::io::RWCursor< access >::insert(), proxygen::HPACKDecodeBuffer::peek(), folly::io::detail::CursorBase< Cursor, const IOBuf >::peekBytes(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMostSlow(), folly::io::RWCursor< access >::pushAtMost(), folly::io::Appender::pushAtMost(), folly::io::QueueAppender::pushAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedStringSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipNoAdvance(), folly::bser::throwDecodeError(), and folly::io::QueueAppender::write().

                        {
    dcheckIntegrity();
    return crtEnd_ - crtPos_;
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::operator!= ( const Derived &  other ) const

inline

Definition at line 252 of file Cursor.h.

                                              {
    return !operator==(other);
  }

template<class Derived, class BufType>

Derived folly::io::detail::CursorBase< Derived, BufType >::operator+ ( size_t  offset ) const

inline

Definition at line 210 of file Cursor.h.

                                         {
    Derived other(*this);
    other.skip(offset);
    return other;
  }

template<class Derived, class BufType>

Derived& folly::io::detail::CursorBase< Derived, BufType >::operator+= ( size_t  offset )

inline

Definition at line 205 of file Cursor.h.

                                     {
    Derived* p = static_cast<Derived*>(this);
    p->skip(offset);
    return *p;
  }

template<class Derived, class BufType>

Derived folly::io::detail::CursorBase< Derived, BufType >::operator- ( size_t  offset ) const

inline

Definition at line 221 of file Cursor.h.

                                         {
    Derived other(*this);
    other.retreat(offset);
    return other;
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::operator- ( const CursorBase< Derived, BufType > &  other ) const

inline

Return the distance between two cursors.

Definition at line 521 of file Cursor.h.

                                                  {
    BufType* otherBuf = other.crtBuf_;
    size_t len = 0;

    if (otherBuf != crtBuf_) {
      len += other.crtEnd_ - other.crtPos_;

      for (otherBuf = otherBuf->next();
           otherBuf != crtBuf_ && otherBuf != other.buffer_;
           otherBuf = otherBuf->next()) {
        len += otherBuf->length();
      }

      if (otherBuf == other.buffer_) {
        throw_exception<std::out_of_range>("wrap-around");
      }

      len += crtPos_ - crtBegin_;
    } else {
      if (crtPos_ < other.crtPos_) {
        throw_exception<std::out_of_range>("underflow");
      }

      len += crtPos_ - other.crtPos_;
    }

    return len;
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::operator- ( const BufType *  buf ) const

inline

Return the distance from the given IOBuf to the this cursor.

Definition at line 553 of file Cursor.h.

                                             {
    size_t len = 0;

    const BufType* curBuf = buf;
    while (curBuf != crtBuf_) {
      len += curBuf->length();
      curBuf = curBuf->next();
      if (curBuf == buf || curBuf == buffer_) {
        throw_exception<std::out_of_range>("wrap-around");
      }
    }

    len += crtPos_ - crtBegin_;
    return len;
  }

template<class Derived, class BufType>

Derived& folly::io::detail::CursorBase< Derived, BufType >::operator-= ( size_t  offset )

inline

Definition at line 216 of file Cursor.h.

                                     {
    Derived* p = static_cast<Derived*>(this);
    p->retreat(offset);
    return *p;
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::operator== ( const Derived &  other ) const

inline

Compare cursors for equality/inequality.

Two cursors are equal if they are pointing to the same location in the same IOBuf chain.

Definition at line 233 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::operator!=().

                                              {
    const IOBuf* crtBuf = crtBuf_;
    auto crtPos = crtPos_;
    // We can be pointing to the end of a buffer chunk, find first non-empty.
    while (crtPos == crtBuf->tail() && crtBuf != buffer_->prev()) {
      crtBuf = crtBuf->next();
      crtPos = crtBuf->data();
    }

    const IOBuf* crtBufOther = other.crtBuf_;
    auto crtPosOther = other.crtPos_;
    // We can be pointing to the end of a buffer chunk, find first non-empty.
    while (crtPosOther == crtBufOther->tail() &&
           crtBufOther != other.buffer_->prev()) {
      crtBufOther = crtBufOther->next();
      crtPosOther = crtBufOther->data();
    }
    return (crtPos == crtPosOther) && (crtBuf == crtBufOther);
  }

template<class Derived, class BufType>

std::pair<const uint8_t*, size_t> folly::io::detail::CursorBase< Derived, BufType >::peek ( )

inline

Alternate version of peekBytes() that returns a std::pair instead of a ByteRange. (This method pre-dates ByteRange.)

This function will eventually be deprecated.

Definition at line 451 of file Cursor.h.

Referenced by proxygen::SPDYCodec::parseIngress(), proxygen::GzipHeaderCodec::parseNameValues(), and proxygen::HPACKDecodeBuffer::peek().

                                         {
    auto bytes = peekBytes();
    return std::make_pair(bytes.data(), bytes.size());
  }

template<class Derived, class BufType>

ByteRange folly::io::detail::CursorBase< Derived, BufType >::peekBytes ( )

inline

Return the available data in the current buffer. If you want to gather more data from the chain into a contiguous region (for hopefully zero-copy access), use gather() before peekBytes().

Definition at line 436 of file Cursor.h.

Referenced by folly::bser::decodeHeader(), folly::bser::decodeTemplate(), folly::io::StreamCodec::doUncompress(), folly::IOBufCompare::impl(), folly::IOBufHash::operator()(), folly::io::detail::CursorBase< Cursor, const IOBuf >::peek(), folly::Subprocess::pid(), folly::io::detail::Writable< Appender >::pushAtMost(), TEST(), and fizz::transformBufferBlocks().

                        {
    // Ensure that we're pointing to valid data
    size_t available = length();
    while (UNLIKELY(available == 0 && tryAdvanceBuffer())) {
      available = length();
    }
    return ByteRange{data(), available};
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::pull ( void *  buf, size_t  len  )

inline

Definition at line 418 of file Cursor.h.

Referenced by folly::bser::decodeHeader(), proxygen::HPACKDecodeBuffer::decodeLiteral(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), folly::bser::parseBser(), proxygen::GzipHeaderCodec::parseNameValues(), fizz::detail::Reader< Random >::read(), and fizz::detail::readBits24().

                                   {
    if (UNLIKELY(len == 0)) {
      return;
    }
    dcheckIntegrity();
    if (LIKELY(crtPos_ + len <= crtEnd_)) {
      memcpy(buf, data(), len);
      crtPos_ += len;
    } else {
      pullSlow(buf, len);
    }
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::pullAtMost ( void *  buf, size_t  len  )

inline

Definition at line 407 of file Cursor.h.

Referenced by folly::AsyncSSLSocket::bioRead(), folly::bser::decodeString(), folly::AsyncSocket::performRead(), and prefixBaseline().

                                           {
    dcheckIntegrity();
    // Fast path: it all fits in one buffer.
    if (LIKELY(crtPos_ + len <= crtEnd_)) {
      memcpy(buf, data(), len);
      crtPos_ += len;
      return len;
    }
    return pullAtMostSlow(buf, len);
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::pullAtMostSlow ( void *  buf, size_t  len  )

inlineprivate

Definition at line 647 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullSlow(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRead().

                                               {
    // If the length of this buffer is 0 try advancing it.
    // Otherwise on the first iteration of the following loop memcpy is called
    // with a null source pointer.
    if (UNLIKELY(length() == 0 && !tryAdvanceBuffer())) {
      return 0;
    }
    uint8_t* p = reinterpret_cast<uint8_t*>(buf);
    size_t copied = 0;
    for (size_t available; (available = length()) < len;) {
      memcpy(p, data(), available);
      copied += available;
      if (UNLIKELY(!tryAdvanceBuffer())) {
        return copied;
      }
      p += available;
      len -= available;
    }
    memcpy(p, data(), len);
    crtPos_ += len;
    advanceBufferIfEmpty();
    return copied + len;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::pullSlow ( void *  buf, size_t  len  )

inlineprivate

Definition at line 671 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::pull(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::readSlow().

                                       {
    if (UNLIKELY(pullAtMostSlow(buf, len) != len)) {
      throw_exception<std::out_of_range>("underflow");
    }
  }

template<class Derived, class BufType>

template<class T >

T folly::io::detail::CursorBase< Derived, BufType >::read ( )

inline

Definition at line 282 of file Cursor.h.

Referenced by folly::bser::decodeInt(), folly::bser::decodeObject(), folly::bser::decodeTemplate(), folly::io::StreamCodec::doUncompress(), proxygen::SPDYCodec::onControlFrame(), folly::bser::parseBser(), proxygen::RFC1867Codec::readToBoundary(), TEST(), and TEST_F().

           {
    if (LIKELY(crtPos_ + sizeof(T) <= crtEnd_)) {
      T val = loadUnaligned<T>(data());
      crtPos_ += sizeof(T);
      return val;
    } else {
      return readSlow<T>();
    }
  }

template<class Derived, class BufType>

template<class T >

T folly::io::detail::CursorBase< Derived, BufType >::readBE ( )

inline

Definition at line 293 of file Cursor.h.

Referenced by fizz::extensions::Validator::constructEcKeyFromBuf(), proxygen::compress::HPACKScheme::decode(), proxygen::compress::QPACKScheme::decode(), proxygen::SPDYCodec::onControlFrame(), proxygen::SPDYCodec::parseIngress(), fizz::detail::Reader< U >::read(), fizz::detail::Reader< Extension >::read(), fizz::detail::readBuf(), and fizz::detail::ReadVector< N, T >::readVector().

             {
    return Endian::big(read<T>());
  }

template<class Derived, class BufType>

std::string folly::io::detail::CursorBase< Derived, BufType >::readFixedString ( size_t  len )

inline

Read a fixed-length string.

The std::string-based APIs should probably be avoided unless you ultimately want the data to live in an std::string. You're better off using the pull() APIs to copy into a raw buffer otherwise.

Definition at line 309 of file Cursor.h.

Referenced by proxygen::HTTP2Codec::onIngress().

                                        {
    std::string str;
    str.reserve(len);
    if (LIKELY(length() >= len)) {
      str.append(reinterpret_cast<const char*>(data()), len);
      crtPos_ += len;
    } else {
      readFixedStringSlow(&str, len);
    }
    return str;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::readFixedStringSlow ( std::string *  str, size_t  len  )

inlineprivate

Definition at line 634 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString().

                                                       {
    for (size_t available; (available = length()) < len;) {
      str->append(reinterpret_cast<const char*>(data()), available);
      if (UNLIKELY(!tryAdvanceBuffer())) {
        throw_exception<std::out_of_range>("string underflow");
      }
      len -= available;
    }
    str->append(reinterpret_cast<const char*>(data()), len);
    crtPos_ += len;
    advanceBufferIfEmpty();
  }

template<class Derived, class BufType>

template<class T >

T folly::io::detail::CursorBase< Derived, BufType >::readLE ( )

inline

Definition at line 298 of file Cursor.h.

Referenced by proxygen::SPDYCodec::onControlFrame().

             {
    return Endian::little(read<T>());
  }

template<class Derived, class BufType>

template<class T >

FOLLY_NOINLINE T folly::io::detail::CursorBase< Derived, BufType >::readSlow ( )

inlineprivate

Definition at line 628 of file Cursor.h.

                              {
    T val;
    pullSlow(&val, sizeof(T));
    return val;
  }

template<class Derived , class BufType >

std::string folly::io::detail::CursorBase< Derived, BufType >::readTerminatedString	(	char	termChar = '\0',
		size_t	maxLength = std::numeric_limits<size_t>::max()
	)

Read a string consisting of bytes until the given terminator character is seen. Raises an std::length_error if maxLength bytes have been processed before the terminator is seen.

See comments in readFixedString() about when it's appropriate to use this vs. using pull().

Definition at line 45 of file Cursor-inl.h.

References folly::gen::skip(), and uint8_t.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString().

                      {
  size_t bytesRead{0};
  auto keepReading = [&bytesRead, termChar, maxLength](uint8_t byte) {
    if (byte == termChar) {
      return false;
    }
    ++bytesRead;
    if (bytesRead >= maxLength) {
      throw std::length_error("string overflow");
    }
    return true;
  };

  auto result = readWhile(keepReading);
  // skip over the terminator character
  if (isAtEnd()) {
    throw_exception<std::out_of_range>("terminator not found");
  }
  skip(1);

  return result;
}

template<class Derived , class BufType >

template<typename Predicate >

std::string folly::io::detail::CursorBase< Derived, BufType >::readWhile

(

const Predicate &

predicate

)

Definition at line 72 of file Cursor-inl.h.

References folly::io::detail::CursorStringAppender::extractString(), and s.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString().

                                {
  CursorStringAppender s;
  readWhile(predicate, s);
  return s.extractString();
}

template<class Derived , class BufType >

template<typename Predicate , typename Output >

void folly::io::detail::CursorBase< Derived, BufType >::readWhile	(	const Predicate &	predicate,
		Output &	out
	)

Definition at line 81 of file Cursor-inl.h.

References folly::gen::skip().

                 {
  while (true) {
    auto peeked = peekBytes();
    if (peeked.empty()) {
      return;
    }
    for (size_t idx = 0; idx < peeked.size(); ++idx) {
      if (!predicate(peeked[idx])) {
        peeked.reset(peeked.data(), idx);
        out.append(peeked);
        skip(idx);
        return;
      }
    }
    out.append(peeked);
    skip(peeked.size());
  }
}

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::reset ( BufType *  buf )

inline

Reset cursor to point to a new buffer.

Definition at line 87 of file Cursor.h.

                           {
    crtBuf_ = buf;
    buffer_ = buf;
    absolutePos_ = 0;
    if (crtBuf_) {
      crtPos_ = crtBegin_ = crtBuf_->data();
      crtEnd_ = crtBuf_->tail();
    }
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::retreat ( size_t  len )

inline

Definition at line 398 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-=().

                           {
    dcheckIntegrity();
    if (len <= static_cast<size_t>(crtPos_ - crtBegin_)) {
      crtPos_ -= len;
    } else {
      retreatSlow(len);
    }
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::retreatAtMost ( size_t  len )

inline

Definition at line 389 of file Cursor.h.

                                   {
    dcheckIntegrity();
    if (len <= static_cast<size_t>(crtPos_ - crtBegin_)) {
      crtPos_ -= len;
      return len;
    }
    return retreatAtMostSlow(len);
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::retreatAtMostSlow ( size_t  len )

inlineprivate

Definition at line 697 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMost(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatSlow().

                                       {
    size_t retreated = 0;
    for (size_t available; (available = crtPos_ - crtBegin_) < len;) {
      retreated += available;
      if (UNLIKELY(!tryRetreatBuffer())) {
        return retreated;
      }
      len -= available;
    }
    crtPos_ -= len;
    return retreated + len;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::retreatSlow ( size_t  len )

inlineprivate

Definition at line 710 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::retreat().

                               {
    if (UNLIKELY(retreatAtMostSlow(len) != len)) {
      throw_exception<std::out_of_range>("underflow");
    }
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::skip ( size_t  len )

inline

Definition at line 371 of file Cursor.h.

Referenced by proxygen::HPACKDecodeBuffer::decodeLiteral(), folly::IOBufCompare::impl(), proxygen::HPACKDecodeBuffer::next(), proxygen::SPDYCodec::onControlFrame(), folly::IOBufHash::operator()(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator+=(), proxygen::HTTP2Codec::parseFrame(), proxygen::GzipHeaderCodec::parseNameValues(), folly::io::detail::Writable< Appender >::pushAtMost(), proxygen::RFC1867Codec::readToBoundary(), TEST(), TEST_F(), and fizz::transformBufferBlocks().

                        {
    dcheckIntegrity();
    if (LIKELY(crtPos_ + len < crtEnd_)) {
      crtPos_ += len;
    } else {
      skipSlow(len);
    }
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::skipAtMost ( size_t  len )

inline

Definition at line 362 of file Cursor.h.

Referenced by folly::bser::decodeTemplate().

                                {
    dcheckIntegrity();
    if (LIKELY(crtPos_ + len < crtEnd_)) {
      crtPos_ += len;
      return len;
    }
    return skipAtMostSlow(len);
  }

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::skipAtMostSlow ( size_t  len )

inlineprivate

Definition at line 677 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMost(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::skipSlow().

                                    {
    size_t skipped = 0;
    for (size_t available; (available = length()) < len;) {
      skipped += available;
      if (UNLIKELY(!tryAdvanceBuffer())) {
        return skipped;
      }
      len -= available;
    }
    crtPos_ += len;
    advanceBufferIfEmpty();
    return skipped + len;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::skipNoAdvance ( size_t  len )

inline

Skip bytes in the current IOBuf without advancing to the next one. Precondition: length() >= len

Definition at line 384 of file Cursor.h.

                                 {
    DCHECK_LE(len, length());
    crtPos_ += len;
  }

template<class Derived, class BufType>

void folly::io::detail::CursorBase< Derived, BufType >::skipSlow ( size_t  len )

inlineprivate

Definition at line 691 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::skip().

                            {
    if (UNLIKELY(skipAtMostSlow(len) != len)) {
      throw_exception<std::out_of_range>("underflow");
    }
  }

template<class Derived , class BufType >

template<typename Predicate >

void folly::io::detail::CursorBase< Derived, BufType >::skipWhile

(

const Predicate &

predicate

)

Definition at line 104 of file Cursor-inl.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString().

                                                                       {
  CursorNoopAppender appender;
  readWhile(predicate, appender);
}

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::totalLength ( ) const

inline

Return the space available until the end of the entire IOBuf chain.

Definition at line 126 of file Cursor.h.

Referenced by folly::io::RWCursor< access >::gather(), folly::io::RWCursor< access >::gatherAtMost(), proxygen::HTTP2Codec::onIngress(), proxygen::SPDYCodec::parseIngress(), fizz::detail::ReadVector< N, T >::readVector(), fizz::detail::ReadVector< bits24, T >::readVector(), proxygen::HPACKDecodeBuffer::reset(), and TEST().

                             {
    if (crtBuf_ == buffer_) {
      return crtBuf_->computeChainDataLength() - (crtPos_ - crtBegin_);
    }
    CursorBase end(buffer_->prev());
    end.crtPos_ = end.crtEnd_;
    return end - *this;
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::tryAdvanceBuffer ( )

inlineprotected

Definition at line 584 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceBufferIfEmpty(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::peekBytes(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMostSlow(), folly::io::RWCursor< access >::pushAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedStringSlow(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMostSlow().

                          {
    BufType* nextBuf = crtBuf_->next();
    if (UNLIKELY(nextBuf == buffer_)) {
      crtPos_ = crtEnd_;
      return false;
    }

    absolutePos_ += crtEnd_ - crtBegin_;
    crtBuf_ = nextBuf;
    crtPos_ = crtBegin_ = crtBuf_->data();
    crtEnd_ = crtBuf_->tail();
    static_cast<Derived*>(this)->advanceDone();
    return true;
  }

template<class Derived, class BufType>

template<class T >

std::enable_if<std::is_arithmetic<T>::value, bool>::type folly::io::detail::CursorBase< Derived, BufType >::tryRead ( T &  val )

inline

Definition at line 257 of file Cursor.h.

Referenced by TEST(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryReadBE(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryReadLE().

              {
    if (LIKELY(crtPos_ + sizeof(T) <= crtEnd_)) {
      val = loadUnaligned<T>(data());
      crtPos_ += sizeof(T);
      return true;
    }
    return pullAtMostSlow(&val, sizeof(T)) == sizeof(T);
  }

template<class Derived, class BufType>

template<class T >

bool folly::io::detail::CursorBase< Derived, BufType >::tryReadBE ( T &  val )

inline

Definition at line 268 of file Cursor.h.

Referenced by TEST().

                         {
    const bool result = tryRead(val);
    val = Endian::big(val);
    return result;
  }

template<class Derived, class BufType>

template<class T >

bool folly::io::detail::CursorBase< Derived, BufType >::tryReadLE ( T &  val )

inline

Definition at line 275 of file Cursor.h.

Referenced by prefix(), and TEST().

                         {
    const bool result = tryRead(val);
    val = Endian::little(val);
    return result;
  }

template<class Derived, class BufType>

bool folly::io::detail::CursorBase< Derived, BufType >::tryRetreatBuffer ( )

inlineprotected

Definition at line 599 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMostSlow().

                          {
    if (UNLIKELY(crtBuf_ == buffer_)) {
      crtPos_ = crtBegin_;
      return false;
    }
    crtBuf_ = crtBuf_->prev();
    crtBegin_ = crtBuf_->data();
    crtPos_ = crtEnd_ = crtBuf_->tail();
    absolutePos_ -= crtEnd_ - crtBegin_;
    static_cast<Derived*>(this)->advanceDone();
    return true;
  }

Friends And Related Function Documentation

template<class Derived, class BufType>

template<class D , typename B >

friend class CursorBase

friend

Definition at line 59 of file Cursor.h.

Member Data Documentation

template<class Derived, class BufType>

size_t folly::io::detail::CursorBase< Derived, BufType >::absolutePos_ {0}

protected

Definition at line 624 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::getCurrentPosition(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer().

template<class Derived, class BufType>

BufType* folly::io::detail::CursorBase< Derived, BufType >::buffer_

protected

Definition at line 620 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::canAdvance(), folly::io::Appender::ensure(), folly::io::detail::CursorBase< Cursor, const IOBuf >::head(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::totalLength(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), folly::io::Appender::tryGrowChain(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer().

template<class Derived, class BufType>

const uint8_t* folly::io::detail::CursorBase< Derived, BufType >::crtBegin_ {nullptr}

protected

Definition at line 621 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::CursorBase(), folly::io::detail::CursorBase< Cursor, const IOBuf >::dcheckIntegrity(), folly::io::RWCursor< access >::gather(), folly::io::RWCursor< access >::gatherAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::getCurrentPosition(), folly::io::RWCursor< access >::insert(), folly::io::RWCursor< access >::maybeUnshare(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreat(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::totalLength(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer(), and folly::io::RWCursor< access >::writableData().

template<class Derived, class BufType>

BufType* folly::io::detail::CursorBase< Derived, BufType >::crtBuf_

protected

Definition at line 619 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::Appender::append(), folly::io::detail::CursorBase< Cursor, const IOBuf >::canAdvance(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::CursorBase(), folly::io::detail::CursorBase< Cursor, const IOBuf >::dcheckIntegrity(), folly::io::Appender::ensure(), folly::io::RWCursor< access >::gather(), folly::io::RWCursor< access >::gatherAtMost(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::io::Appender::length(), folly::io::RWCursor< access >::maybeUnshare(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::totalLength(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), folly::io::Appender::tryGrowChain(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer(), folly::io::RWCursor< access >::writableData(), and folly::io::Appender::writableData().

template<class Derived, class BufType>

const uint8_t* folly::io::detail::CursorBase< Derived, BufType >::crtEnd_ {nullptr}

protected

Definition at line 622 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceBufferIfEmpty(), folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::CursorBase(), folly::io::detail::CursorBase< Cursor, const IOBuf >::dcheckIntegrity(), folly::io::RWCursor< access >::gather(), folly::io::RWCursor< access >::gatherAtMost(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::length(), folly::io::RWCursor< access >::maybeUnshare(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pull(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::read(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skip(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRead(), and folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer().

template<class Derived, class BufType>

const uint8_t* folly::io::detail::CursorBase< Derived, BufType >::crtPos_ {nullptr}

protected

Definition at line 623 of file Cursor.h.

Referenced by folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceBufferIfEmpty(), folly::io::detail::CursorBase< Cursor, const IOBuf >::advanceToEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::CursorBase(), folly::io::detail::CursorBase< Cursor, const IOBuf >::data(), folly::io::detail::CursorBase< Cursor, const IOBuf >::dcheckIntegrity(), folly::io::RWCursor< access >::gather(), folly::io::RWCursor< access >::gatherAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::getCurrentPosition(), folly::io::RWCursor< access >::insert(), folly::io::detail::CursorBase< Cursor, const IOBuf >::isAtEnd(), folly::io::detail::CursorBase< Cursor, const IOBuf >::length(), folly::io::RWCursor< access >::maybeUnshare(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator-(), folly::io::detail::CursorBase< Cursor, const IOBuf >::operator==(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pull(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::pullAtMostSlow(), folly::io::RWCursor< access >::pushAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::read(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedString(), folly::io::detail::CursorBase< Cursor, const IOBuf >::readFixedStringSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::reset(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreat(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::retreatAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skip(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMost(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipAtMostSlow(), folly::io::detail::CursorBase< Cursor, const IOBuf >::skipNoAdvance(), folly::io::detail::CursorBase< Cursor, const IOBuf >::totalLength(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryAdvanceBuffer(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRead(), folly::io::detail::CursorBase< Cursor, const IOBuf >::tryRetreatBuffer(), and folly::io::RWCursor< access >::writableData().

---

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

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