proxygen: folly::io::RWCursor< access > Class Template Reference

#include <Cursor.h>

Inheritance diagram for folly::io::RWCursor< access >:

Public Member Functions
	RWCursor (IOBuf *buf)

template<class OtherDerived , class OtherBuf >
	RWCursor (const detail::CursorBase< OtherDerived, OtherBuf > &cursor)

void	gather (size_t n)

void	gatherAtMost (size_t n)

size_t	pushAtMost (const uint8_t *buf, size_t len)

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

uint8_t *	writableData ()

Public Member Functions inherited from folly::io::detail::CursorBase< RWCursor< access >, IOBuf >
	CursorBase (IOBuf *buf)

	CursorBase (const CursorBase< OtherDerived, OtherBuf > &cursor)

void	reset (IOBuf *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 ()

RWCursor< access > &	operator+= (size_t offset)

RWCursor< access >	operator+ (size_t offset) const

RWCursor< access > &	operator-= (size_t offset)

RWCursor< access >	operator- (size_t offset) const

size_t	operator- (const CursorBase &other) const

size_t	operator- (const IOBuf *buf) const

bool	operator== (const RWCursor< access > &other) const

bool	operator!= (const RWCursor< access > &other) const

std::enable_if< std::is_arithmetic< T >::value, bool >::type	tryRead (T &val)

bool	tryReadBE (T &val)

bool	tryReadLE (T &val)

T	read ()

T	readBE ()

T	readLE ()

std::string	readFixedString (size_t len)

std::string	readTerminatedString (char termChar= '\0', size_t maxLength=std::numeric_limits< size_t >::max())

std::string	readWhile (const Predicate &predicate)

void	readWhile (const Predicate &predicate, Output &out)

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)

Public Member Functions inherited from folly::io::detail::Writable< RWCursor< access > >
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
void	maybeUnshare ()

void	advanceDone ()

Private Attributes
bool	maybeShared_

Friends
class	detail::CursorBase< RWCursor< access >, IOBuf >

Additional Inherited Members
Protected Member Functions inherited from folly::io::detail::CursorBase< RWCursor< access >, IOBuf >
void	dcheckIntegrity () const

	~CursorBase ()

IOBuf *	head ()

bool	tryAdvanceBuffer ()

bool	tryRetreatBuffer ()

void	advanceBufferIfEmpty ()

Protected Attributes inherited from folly::io::detail::CursorBase< RWCursor< access >, IOBuf >
IOBuf *	crtBuf_

IOBuf *	buffer_

const uint8_t *	crtBegin_

const uint8_t *	crtEnd_

const uint8_t *	crtPos_

size_t	absolutePos_

Detailed Description

template<CursorAccess access>
class folly::io::RWCursor< access >

Definition at line 815 of file Cursor.h.

Constructor & Destructor Documentation

template<CursorAccess access>

folly::io::RWCursor< access >::RWCursor ( IOBuf * buf )

inlineexplicit

Definition at line 820 of file Cursor.h.

821 : detail::CursorBase<RWCursor<access>, IOBuf>(buf), maybeShared_(true) {}

folly::io::RWCursor::maybeShared_

bool maybeShared_

Definition: Cursor.h:955

template<CursorAccess access>

template<class OtherDerived , class OtherBuf >

folly::io::RWCursor< access >::RWCursor ( const detail::CursorBase< OtherDerived, OtherBuf > & cursor )

inlineexplicit

Definition at line 824 of file Cursor.h.

825 : detail::CursorBase<RWCursor<access>, IOBuf>(cursor),

826 maybeShared_(true) {}

folly::io::RWCursor::maybeShared_

bool maybeShared_

Definition: Cursor.h:955

Member Function Documentation

template<CursorAccess access>

void folly::io::RWCursor< access >::advanceDone ( )

inlineprivate

Definition at line 951 of file Cursor.h.

                      {
     maybeShared_ = true;
   }

template<CursorAccess access>

void folly::io::RWCursor< access >::gather ( size_t n )

inline

Gather at least n bytes contiguously into the current buffer, by coalescing subsequent buffers from the chain as necessary.

Definition at line 831 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtBegin_, folly::io::detail::CursorBase< Derived, BufType >::crtBuf_, folly::io::detail::CursorBase< Derived, BufType >::crtEnd_, folly::io::detail::CursorBase< Derived, BufType >::crtPos_, folly::io::detail::CursorBase< Derived, BufType >::head(), and folly::io::detail::CursorBase< Derived, BufType >::totalLength().

Referenced by TEST().

                         {
     // Forbid attempts to gather beyond the end of this IOBuf chain.
     // Otherwise we could try to coalesce the head of the chain and end up
     // accidentally freeing it, invalidating the pointer owned by external
     // code.
     //
     // If crtBuf_ == head() then IOBuf::gather() will perform all necessary
     // checking.  We only have to perform an explicit check here when calling
     // gather() on a non-head element.
     if (this->crtBuf_ != this->head() && this->totalLength() < n) {
       throw std::overflow_error("cannot gather() past the end of the chain");
     }
     size_t offset = this->crtPos_ - this->crtBegin_;
     this->crtBuf_->gather(offset + n);
     this->crtBegin_ = this->crtBuf_->data();
     this->crtEnd_ = this->crtBuf_->tail();
     this->crtPos_ = this->crtBegin_ + offset;
   }

template<CursorAccess access>

void folly::io::RWCursor< access >::gatherAtMost ( size_t n )

inline

Definition at line 849 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtBegin_, folly::io::detail::CursorBase< Derived, BufType >::crtBuf_, folly::io::detail::CursorBase< Derived, BufType >::crtEnd_, folly::io::detail::CursorBase< Derived, BufType >::crtPos_, folly::io::detail::CursorBase< Derived, BufType >::dcheckIntegrity(), min, folly::size(), and folly::io::detail::CursorBase< Derived, BufType >::totalLength().

                               {
     this->dcheckIntegrity();
     size_t size = std::min(n, this->totalLength());
     size_t offset = this->crtPos_ - this->crtBegin_;
     this->crtBuf_->gather(offset + size);
     this->crtBegin_ = this->crtBuf_->data();
     this->crtEnd_ = this->crtBuf_->tail();
     this->crtPos_ = this->crtBegin_ + offset;
   }

template<CursorAccess access>

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

inline

Definition at line 895 of file Cursor.h.

                                              {
     this->dcheckIntegrity();
     this->absolutePos_ += buf->computeChainDataLength();
     if (this->crtPos_ == this->crtBegin_ && this->crtBuf_ != this->buffer_) {
       // Can just prepend
       this->crtBuf_->prependChain(std::move(buf));
     } else {
       IOBuf* nextBuf;
       std::unique_ptr<folly::IOBuf> remaining;
       if (this->crtPos_ != this->crtEnd_) {
         // Need to split current IOBuf in two.
         remaining = this->crtBuf_->cloneOne();
         remaining->trimStart(this->crtPos_ - this->crtBegin_);
         nextBuf = remaining.get();
         buf->prependChain(std::move(remaining));
       } else {
         // Can just append
         nextBuf = this->crtBuf_->next();
       }
       this->crtBuf_->trimEnd(this->length());
       this->absolutePos_ += this->crtPos_ - this->crtBegin_;
       this->crtBuf_->appendChain(std::move(buf));
 
       if (nextBuf == this->buffer_) {
         // We've just appended to the end of the buffer, so advance to the end.
         this->crtBuf_ = this->buffer_->prev();
         this->crtBegin_ = this->crtBuf_->data();
         this->crtPos_ = this->crtEnd_ = this->crtBuf_->tail();
         // This has already been accounted for, so remove it.
         this->absolutePos_ -= this->crtEnd_ - this->crtBegin_;
       } else {
         // Jump past the new links
         this->crtBuf_ = nextBuf;
         this->crtPos_ = this->crtBegin_ = this->crtBuf_->data();
         this->crtEnd_ = this->crtBuf_->tail();
       }
     }
   }

template<CursorAccess access>

void folly::io::RWCursor< access >::maybeUnshare ( )

inlineprivate

Definition at line 940 of file Cursor.h.

                       {
     if (UNLIKELY(maybeShared_)) {
       size_t offset = this->crtPos_ - this->crtBegin_;
       this->crtBuf_->unshareOne();
       this->crtBegin_ = this->crtBuf_->data();
       this->crtEnd_ = this->crtBuf_->tail();
       this->crtPos_ = this->crtBegin_ + offset;
       maybeShared_ = false;
     }
   }

template<CursorAccess access>

size_t folly::io::RWCursor< access >::pushAtMost	(	const uint8_t *	buf,
		size_t	len
	)

inline

Definition at line 860 of file Cursor.h.

References folly::io::detail::CursorBase< Derived, BufType >::crtPos_, folly::io::detail::CursorBase< Derived, BufType >::length(), LIKELY, folly::io::detail::CursorBase< Derived, BufType >::tryAdvanceBuffer(), UNLIKELY, and folly::io::UNSHARE.

                                                     {
     // 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;
     }
 
     size_t copied = 0;
     for (;;) {
       // Fast path: the current buffer is big enough.
       size_t available = this->length();
       if (LIKELY(available >= len)) {
         if (access == CursorAccess::UNSHARE) {
           maybeUnshare();
         }
         memcpy(writableData(), buf, len);
         this->crtPos_ += len;
         return copied + len;
       }
 
       if (access == CursorAccess::UNSHARE) {
         maybeUnshare();
       }
       memcpy(writableData(), buf, available);
       copied += available;
       if (UNLIKELY(!this->tryAdvanceBuffer())) {
         return copied;
       }
       buf += available;
       len -= available;
     }
   }

template<CursorAccess access>

uint8_t* folly::io::RWCursor< access >::writableData ( )

inline

Definition at line 934 of file Cursor.h.

Referenced by fizz::transformBufferBlocks().

                           {
     this->dcheckIntegrity();
     return this->crtBuf_->writableData() + (this->crtPos_ - this->crtBegin_);
   }

Friends And Related Function Documentation

template<CursorAccess access>

friend class detail::CursorBase< RWCursor< access >, IOBuf >

friend

Definition at line 817 of file Cursor.h.

Member Data Documentation

template<CursorAccess access>

bool folly::io::RWCursor< access >::maybeShared_

private

Definition at line 955 of file Cursor.h.

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

proxygen/folly/folly/io/Cursor.h

Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

template<CursorAccess access> class folly::io::RWCursor< access >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<CursorAccess access>
class folly::io::RWCursor< access >