#include <coded_stream.h>

Public Types
typedef int	Limit

Public Member Functions
	CodedInputStream (ZeroCopyInputStream *input)

	CodedInputStream (const uint8 *buffer, int size)

	~CodedInputStream ()

bool	IsFlat () const

bool	Skip (int count)

bool	GetDirectBufferPointer (const void *data, int size)

void	GetDirectBufferPointerInline (const void *data, int size) GOOGLE_ATTRIBUTE_ALWAYS_INLINE

bool	ReadRaw (void *buffer, int size)

bool	ReadString (string *buffer, int size)

bool	InternalReadStringInline (string *buffer, int size) GOOGLE_ATTRIBUTE_ALWAYS_INLINE

bool	ReadLittleEndian32 (uint32 *value)

bool	ReadLittleEndian64 (uint64 *value)

bool	ReadVarint32 (uint32 *value)

bool	ReadVarint64 (uint64 *value)

uint32	ReadTag () GOOGLE_ATTRIBUTE_ALWAYS_INLINE

std::pair< uint32, bool >	ReadTagWithCutoff (uint32 cutoff) GOOGLE_ATTRIBUTE_ALWAYS_INLINE

bool	ExpectTag (uint32 expected) GOOGLE_ATTRIBUTE_ALWAYS_INLINE

bool	ExpectAtEnd ()

bool	LastTagWas (uint32 expected)

bool	ConsumedEntireMessage ()

Limit	PushLimit (int byte_limit)

void	PopLimit (Limit limit)

int	BytesUntilLimit () const

int	CurrentPosition () const

void	SetTotalBytesLimit (int total_bytes_limit, int warning_threshold)

int	BytesUntilTotalBytesLimit () const

void	SetRecursionLimit (int limit)

bool	IncrementRecursionDepth ()

void	DecrementRecursionDepth ()

void	SetExtensionRegistry (const DescriptorPool pool, MessageFactory factory)

const DescriptorPool *	GetExtensionPool ()

MessageFactory *	GetExtensionFactory ()

Static Public Member Functions
static const uint8 *	ReadLittleEndian32FromArray (const uint8 buffer, uint32 value)

static const uint8 *	ReadLittleEndian64FromArray (const uint8 buffer, uint64 value)

static const uint8 *	ExpectTagFromArray (const uint8 *buffer, uint32 expected) GOOGLE_ATTRIBUTE_ALWAYS_INLINE

Private Member Functions
	GOOGLE_DISALLOW_EVIL_CONSTRUCTORS (CodedInputStream)

void	Advance (int amount)

void	BackUpInputToCurrentPosition ()

void	RecomputeBufferLimits ()

void	PrintTotalBytesLimitError ()

bool	Refresh ()

bool	ReadVarint32Fallback (uint32 *value)

bool	ReadVarint64Fallback (uint64 *value)

bool	ReadVarint32Slow (uint32 *value)

bool	ReadVarint64Slow (uint64 *value)

bool	ReadLittleEndian32Fallback (uint32 *value)

bool	ReadLittleEndian64Fallback (uint64 *value)

uint32	ReadTagFallback ()

uint32	ReadTagSlow ()

bool	ReadStringFallback (string *buffer, int size)

int	BufferSize () const

Private Attributes
ZeroCopyInputStream *	input_

const uint8 *	buffer_

const uint8 *	buffer_end_

int	total_bytes_read_

int	overflow_bytes_

uint32	last_tag_

bool	legitimate_message_end_

bool	aliasing_enabled_

Limit	current_limit_

int	buffer_size_after_limit_

int	total_bytes_limit_

int	total_bytes_warning_threshold_

int	recursion_depth_

int	recursion_limit_

const DescriptorPool *	extension_pool_

MessageFactory *	extension_factory_

Static Private Attributes
static const int	kDefaultTotalBytesLimit = 64 << 20

static const int	kDefaultTotalBytesWarningThreshold = 32 << 20

static int	default_recursion_limit_

Member Typedef Documentation

typedef int google::protobuf::io::CodedInputStream::Limit

Constructor & Destructor Documentation

google::protobuf::io::CodedInputStream::CodedInputStream ( ZeroCopyInputStream * input )

inlineexplicit

  : input_(input),
  buffer_(NULL),
  buffer_end_(NULL),
  total_bytes_read_(0),
  overflow_bytes_(0),
  last_tag_(0),
  legitimate_message_end_(false),
  aliasing_enabled_(false),
  current_limit_(kint32max),
  buffer_size_after_limit_(0),
  total_bytes_limit_(kDefaultTotalBytesLimit),
  total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
  recursion_depth_(0),
  recursion_limit_(default_recursion_limit_),
  extension_pool_(NULL),
  extension_factory_(NULL) {
  // Eagerly Refresh() so buffer space is immediately available.
  Refresh();
 }

Here is the call graph for this function:

google::protobuf::io::CodedInputStream::CodedInputStream	(	const uint8 *	buffer,
		int	size
	)

inlineexplicit

  : input_(NULL),
  buffer_(buffer),
  buffer_end_(buffer + size),
  total_bytes_read_(size),
  overflow_bytes_(0),
  last_tag_(0),
  legitimate_message_end_(false),
  aliasing_enabled_(false),
  current_limit_(size),
  buffer_size_after_limit_(0),
  total_bytes_limit_(kDefaultTotalBytesLimit),
  total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
  recursion_depth_(0),
  recursion_limit_(default_recursion_limit_),
  extension_pool_(NULL),
  extension_factory_(NULL) {
  // Note that setting current_limit_ == size is important to prevent some
  // code paths from trying to access input_ and segfaulting.
 }

google::protobuf::io::CodedInputStream::~CodedInputStream ( )

Member Function Documentation

void google::protobuf::io::CodedInputStream::Advance ( int amount )

inlineprivate

  {
  buffer_ += amount;
 }

Here is the caller graph for this function:

void google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition ( )

private

int google::protobuf::io::CodedInputStream::BufferSize ( ) const

inlineprivate

  {
  return buffer_end_ - buffer_;
 }

Here is the caller graph for this function:

int google::protobuf::io::CodedInputStream::BytesUntilLimit ( ) const

Here is the caller graph for this function:

int google::protobuf::io::CodedInputStream::BytesUntilTotalBytesLimit ( ) const

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ConsumedEntireMessage ( )

inline

  {
  return legitimate_message_end_;
 }

Here is the caller graph for this function:

int google::protobuf::io::CodedInputStream::CurrentPosition ( ) const

inline

  {
  return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
 }

Here is the call graph for this function:

void google::protobuf::io::CodedInputStream::DecrementRecursionDepth ( )

inline

  {
  if (recursion_depth_ > 0) --recursion_depth_;
 }

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ExpectAtEnd ( )

inline

  {
  // If we are at a limit we know no more bytes can be read. Otherwise, it's
  // hard to say without calling Refresh(), and we'd rather not do that.
 
  if (buffer_ == buffer_end_ &&
  ((buffer_size_after_limit_ != 0) ||
  (total_bytes_read_ == current_limit_))) {
  last_tag_ = 0; // Pretend we called ReadTag()...
  legitimate_message_end_ = true; // ... and it hit EOF.
  return true;
  } else {
  return false;
  }
 }

bool google::protobuf::io::CodedInputStream::ExpectTag ( uint32 expected )

inline

  {
  if (expected < (1 << 7)) {
  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] == expected) {
  Advance(1);
  return true;
  } else {
  return false;
  }
  } else if (expected < (1 << 14)) {
  if (GOOGLE_PREDICT_TRUE(BufferSize() >= 2) &&
  buffer_[0] == static_cast<uint8>(expected | 0x80) &&
  buffer_[1] == static_cast<uint8>(expected >> 7)) {
  Advance(2);
  return true;
  } else {
  return false;
  }
  } else {
  // Don't bother optimizing for larger values.
  return false;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const uint8 * google::protobuf::io::CodedInputStream::ExpectTagFromArray	(	const uint8 *	buffer,
		uint32	expected
	)

inlinestatic

  {
  if (expected < (1 << 7)) {
  if (buffer[0] == expected) {
  return buffer + 1;
  }
  } else if (expected < (1 << 14)) {
  if (buffer[0] == static_cast<uint8>(expected | 0x80) &&
  buffer[1] == static_cast<uint8>(expected >> 7)) {
  return buffer + 2;
  }
  }
  return NULL;
 }

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::GetDirectBufferPointer	(	const void **	data,
		int *	size
	)

void google::protobuf::io::CodedInputStream::GetDirectBufferPointerInline	(	const void **	data,
		int *	size
	)

inline

  {
  *data = buffer_;
  *size = buffer_end_ - buffer_;
 }

Here is the caller graph for this function:

MessageFactory * google::protobuf::io::CodedInputStream::GetExtensionFactory ( )

inline

  {
  return extension_factory_;
 }

const DescriptorPool * google::protobuf::io::CodedInputStream::GetExtensionPool ( )

inline

  {
  return extension_pool_;
 }

google::protobuf::io::CodedInputStream::GOOGLE_DISALLOW_EVIL_CONSTRUCTORS ( CodedInputStream )

private

bool google::protobuf::io::CodedInputStream::IncrementRecursionDepth ( )

inline

  {
  ++recursion_depth_;
  return recursion_depth_ <= recursion_limit_;
 }

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::InternalReadStringInline	(	string *	buffer,
		int	size
	)

inline

  {
  if (size < 0) return false; // security: size is often user-supplied
 
  if (BufferSize() >= size) {
  STLStringResizeUninitialized(buffer, size);
  // When buffer is empty, string_as_array(buffer) will return NULL but memcpy
  // requires non-NULL pointers even when size is 0. Hench this check.
  if (size > 0) {
  memcpy(mutable_string_data(buffer), buffer_, size);
  Advance(size);
  }
  return true;
  }
 
  return ReadStringFallback(buffer, size);
 }

Here is the call graph for this function:

bool google::protobuf::io::CodedInputStream::IsFlat ( ) const

inline

  {
  return input_ == NULL;
 }

bool google::protobuf::io::CodedInputStream::LastTagWas ( uint32 expected )

inline

  {
  return last_tag_ == expected;
 }

Here is the caller graph for this function:

void google::protobuf::io::CodedInputStream::PopLimit ( Limit limit )

Here is the caller graph for this function:

void google::protobuf::io::CodedInputStream::PrintTotalBytesLimitError ( )

private

Limit google::protobuf::io::CodedInputStream::PushLimit ( int byte_limit )

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadLittleEndian32 ( uint32 * value )

inline

  {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
  if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
  memcpy(value, buffer_, sizeof(*value));
  Advance(sizeof(*value));
  return true;
  } else {
  return ReadLittleEndian32Fallback(value);
  }
 #else
  return ReadLittleEndian32Fallback(value);
 #endif
 }

Here is the call graph for this function:

bool google::protobuf::io::CodedInputStream::ReadLittleEndian32Fallback ( uint32 * value )

private

Here is the caller graph for this function:

const uint8 * google::protobuf::io::CodedInputStream::ReadLittleEndian32FromArray	(	const uint8 *	buffer,
		uint32 *	value
	)

inlinestatic

  {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
  memcpy(value, buffer, sizeof(*value));
  return buffer + sizeof(*value);
 #else
  *value = (static_cast<uint32>(buffer[0]) ) |
  (static_cast<uint32>(buffer[1]) << 8) |
  (static_cast<uint32>(buffer[2]) << 16) |
  (static_cast<uint32>(buffer[3]) << 24);
  return buffer + sizeof(*value);
 #endif
 }

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadLittleEndian64 ( uint64 * value )

inline

  {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
  if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
  memcpy(value, buffer_, sizeof(*value));
  Advance(sizeof(*value));
  return true;
  } else {
  return ReadLittleEndian64Fallback(value);
  }
 #else
  return ReadLittleEndian64Fallback(value);
 #endif
 }

Here is the call graph for this function:

bool google::protobuf::io::CodedInputStream::ReadLittleEndian64Fallback ( uint64 * value )

private

Here is the caller graph for this function:

const uint8 * google::protobuf::io::CodedInputStream::ReadLittleEndian64FromArray	(	const uint8 *	buffer,
		uint64 *	value
	)

inlinestatic

  {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
  memcpy(value, buffer, sizeof(*value));
  return buffer + sizeof(*value);
 #else
  uint32 part0 = (static_cast<uint32>(buffer[0]) ) |
  (static_cast<uint32>(buffer[1]) << 8) |
  (static_cast<uint32>(buffer[2]) << 16) |
  (static_cast<uint32>(buffer[3]) << 24);
  uint32 part1 = (static_cast<uint32>(buffer[4]) ) |
  (static_cast<uint32>(buffer[5]) << 8) |
  (static_cast<uint32>(buffer[6]) << 16) |
  (static_cast<uint32>(buffer[7]) << 24);
  *value = static_cast<uint64>(part0) |
  (static_cast<uint64>(part1) << 32);
  return buffer + sizeof(*value);
 #endif
 }

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadRaw	(	void *	buffer,
		int	size
	)

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadString	(	string *	buffer,
		int	size
	)

bool google::protobuf::io::CodedInputStream::ReadStringFallback	(	string *	buffer,
		int	size
	)

private

Here is the caller graph for this function:

uint32 google::protobuf::io::CodedInputStream::ReadTag ( )

inline

  {
  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] < 0x80) {
  last_tag_ = buffer_[0];
  Advance(1);
  return last_tag_;
  } else {
  last_tag_ = ReadTagFallback();
  return last_tag_;
  }
 }

Here is the call graph for this function:

uint32 google::protobuf::io::CodedInputStream::ReadTagFallback ( )

private

Here is the caller graph for this function:

uint32 google::protobuf::io::CodedInputStream::ReadTagSlow ( )

private

std::pair< uint32, bool > google::protobuf::io::CodedInputStream::ReadTagWithCutoff ( uint32 cutoff )

inline

  {
  // In performance-sensitive code we can expect cutoff to be a compile-time
  // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
  // compile time.
  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
  // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
  // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
  // is large enough then is it better to check for the two-byte case first?
  if (static_cast<int8>(buffer_[0]) > 0) {
  const uint32 kMax1ByteVarint = 0x7f;
  uint32 tag = last_tag_ = buffer_[0];
  Advance(1);
  return make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
  }
  // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
  // and tag is two bytes. The latter is tested by bitwise-and-not of the
  // first byte and the second byte.
  if (cutoff >= 0x80 &&
  GOOGLE_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
  GOOGLE_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
  const uint32 kMax2ByteVarint = (0x7f << 7) + 0x7f;
  uint32 tag = last_tag_ = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
  Advance(2);
  // It might make sense to test for tag == 0 now, but it is so rare that
  // that we don't bother. A varint-encoded 0 should be one byte unless
  // the encoder lost its mind. The second part of the return value of
  // this function is allowed to be either true or false if the tag is 0,
  // so we don't have to check for tag == 0. We may need to check whether
  // it exceeds cutoff.
  bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
  return make_pair(tag, at_or_below_cutoff);
  }
  }
  // Slow path
  last_tag_ = ReadTagFallback();
  return make_pair(last_tag_, static_cast<uint32>(last_tag_ - 1) < cutoff);
 }

Here is the call graph for this function:

bool google::protobuf::io::CodedInputStream::ReadVarint32 ( uint32 * value )

inline

  {
  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
  *value = *buffer_;
  Advance(1);
  return true;
  } else {
  return ReadVarint32Fallback(value);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadVarint32Fallback ( uint32 * value )

private

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadVarint32Slow ( uint32 * value )

private

bool google::protobuf::io::CodedInputStream::ReadVarint64 ( uint64 * value )

inline

  {
  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
  *value = *buffer_;
  Advance(1);
  return true;
  } else {
  return ReadVarint64Fallback(value);
  }
 }

Here is the call graph for this function:

bool google::protobuf::io::CodedInputStream::ReadVarint64Fallback ( uint64 * value )

private

Here is the caller graph for this function:

bool google::protobuf::io::CodedInputStream::ReadVarint64Slow ( uint64 * value )

private

void google::protobuf::io::CodedInputStream::RecomputeBufferLimits ( )

private

bool google::protobuf::io::CodedInputStream::Refresh ( )

private

Here is the caller graph for this function:

void google::protobuf::io::CodedInputStream::SetExtensionRegistry	(	const DescriptorPool *	pool,
		MessageFactory *	factory
	)

inline

  {
  extension_pool_ = pool;
  extension_factory_ = factory;
 }

void google::protobuf::io::CodedInputStream::SetRecursionLimit ( int limit )

inline

  {
  recursion_limit_ = limit;
 }

void google::protobuf::io::CodedInputStream::SetTotalBytesLimit	(	int	total_bytes_limit,
		int	warning_threshold
	)

bool google::protobuf::io::CodedInputStream::Skip ( int count )

Here is the caller graph for this function:

Member Data Documentation

bool google::protobuf::io::CodedInputStream::aliasing_enabled_

private

const uint8* google::protobuf::io::CodedInputStream::buffer_

private

const uint8* google::protobuf::io::CodedInputStream::buffer_end_

private

int google::protobuf::io::CodedInputStream::buffer_size_after_limit_

private

Limit google::protobuf::io::CodedInputStream::current_limit_

private

int google::protobuf::io::CodedInputStream::default_recursion_limit_

staticprivate

MessageFactory* google::protobuf::io::CodedInputStream::extension_factory_

private

const DescriptorPool* google::protobuf::io::CodedInputStream::extension_pool_

private

ZeroCopyInputStream* google::protobuf::io::CodedInputStream::input_

private

const int google::protobuf::io::CodedInputStream::kDefaultTotalBytesLimit = 64 << 20

staticprivate

const int google::protobuf::io::CodedInputStream::kDefaultTotalBytesWarningThreshold = 32 << 20

staticprivate

uint32 google::protobuf::io::CodedInputStream::last_tag_

private

bool google::protobuf::io::CodedInputStream::legitimate_message_end_

private

int google::protobuf::io::CodedInputStream::overflow_bytes_

private

int google::protobuf::io::CodedInputStream::recursion_depth_

private

int google::protobuf::io::CodedInputStream::recursion_limit_

private

int google::protobuf::io::CodedInputStream::total_bytes_limit_

private

int google::protobuf::io::CodedInputStream::total_bytes_read_

private

int google::protobuf::io::CodedInputStream::total_bytes_warning_threshold_

private

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

dep/protobuf/src/google/protobuf/io/coded_stream.h
dep/protobuf/src/google/protobuf/io/coded_stream_inl.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation