class CodedInputStream

Sets *data to point directly at the unread part of the CodedInputStream's

underlying buffer, and *size to the size of that buffer, but does not

advance the stream's current position. This will always either produce

a non-empty buffer or return false. If the caller consumes any of

this data, it should then call Skip() to skip over the consumed bytes.

This may be useful for implementing external fast parsing routines for

types of data not covered by the CodedInputStream interface.

Read raw bytes, copying them into the given buffer.

Like ReadRaw, but reads into a string.

Like ReadString(), but reads to a Cord.

Read a tag. This calls ReadVarint32() and returns the result, or returns

zero (which is not a valid tag) if ReadVarint32() fails. Also, ReadTag

(but not ReadTagNoLastTag) updates the last tag value, which can be checked

with LastTagWas().

Always inline because this is only called in one place per parse loop

but it is called for every iteration of said loop, so it should be fast.

GCC doesn't want to inline this by default.

This usually a faster alternative to ReadTag() when cutoff is a manifest

constant. It does particularly well for cutoff >= 127. The first part

of the return value is the tag that was read, though it can also be 0 in

the cases where ReadTag() would return 0. If the second part is true

then the tag is known to be in [0, cutoff]. If not, the tag either is

above cutoff or is 0. (There's intentional wiggle room when tag is 0,

because that can arise in several ways, and for best performance we want

to avoid an extra "is tag == 0?" check here.)

Create a CodedInputStream that reads from the given ZeroCopyInputStream.

Create a CodedInputStream that reads from the given flat array. This is

faster than using an ArrayInputStream. PushLimit(size) is implied by

this constructor.

Destroy the CodedInputStream and position the underlying

ZeroCopyInputStream at the first unread byte. If an error occurred while

reading (causing a method to return false), then the exact position of

the input stream may be anywhere between the last value that was read

successfully and the stream's byte limit.

Return true if this CodedInputStream reads from a flat array instead of

a ZeroCopyInputStream.

Skips a number of bytes. Returns false if an underlying read error

occurs.

Like GetDirectBufferPointer, but this method is inlined, and does not

attempt to Refresh() if the buffer is currently empty.

Read a 16-bit little-endian integer.

Read a 32-bit little-endian integer.

Read a 64-bit little-endian integer.

These methods read from an externally provided buffer. The caller is

responsible for ensuring that the buffer has sufficient space.

Read a 16-bit little-endian integer.

Read a 32-bit little-endian integer.

Read a 64-bit little-endian integer.

Read an unsigned integer with Varint encoding, truncating to 32 bits.

Reading a 32-bit value is equivalent to reading a 64-bit one and casting

it to uint32_t, but may be more efficient.

Read an unsigned integer with Varint encoding.

Reads a varint off the wire into an "int". This should be used for reading

sizes off the wire (sizes of strings, submessages, bytes fields, etc).

The value from the wire is interpreted as unsigned. If its value exceeds

the representable value of an integer on this platform, instead of

truncating we return false. Truncating (as performed by ReadVarint32()

above) is an acceptable approach for fields representing an integer, but

when we are parsing a size from the wire, truncating the value would result

in us misparsing the payload.

Usually returns true if calling ReadVarint32() now would produce the given

value. Will always return false if ReadVarint32() would not return the

given value. If ExpectTag() returns true, it also advances past

the varint. For best performance, use a compile-time constant as the

parameter.

Always inline because this collapses to a small number of instructions

when given a constant parameter, but GCC doesn't want to inline by default.

Like above, except this reads from the specified buffer. The caller is

responsible for ensuring that the buffer is large enough to read a varint

of the expected size. For best performance, use a compile-time constant as

the expected tag parameter.

Returns a pointer beyond the expected tag if it was found, or NULL if it

was not.

Usually returns true if no more bytes can be read. Always returns false

if more bytes can be read. If ExpectAtEnd() returns true, a subsequent

call to LastTagWas() will act as if ReadTag() had been called and returned

zero, and ConsumedEntireMessage() will return true.

If the last call to ReadTag() or ReadTagWithCutoff() returned the given

value, returns true. Otherwise, returns false.

ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last

returned value.

This is needed because parsers for some types of embedded messages

(with field type TYPE_GROUP) don't actually know that they've reached the

end of a message until they see an ENDGROUP tag, which was actually part

of the enclosing message. The enclosing message would like to check that

tag to make sure it had the right number, so it calls LastTagWas() on

return from the embedded parser to check.

When parsing message (but NOT a group), this method must be called

immediately after MergeFromCodedStream() returns (if it returns true)

to further verify that the message ended in a legitimate way. For

example, this verifies that parsing did not end on an end-group tag.

It also checks for some cases where, due to optimizations,

MergeFromCodedStream() can incorrectly return true.

Places a limit on the number of bytes that the stream may read,

starting from the current position. Once the stream hits this limit,

it will act like the end of the input has been reached until PopLimit()

is called.

As the names imply, the stream conceptually has a stack of limits. The

shortest limit on the stack is always enforced, even if it is not the

top limit.

The value returned by PushLimit() is opaque to the caller, and must

be passed unchanged to the corresponding call to PopLimit().

Pops the last limit pushed by PushLimit(). The input must be the value

returned by that call to PushLimit().

Returns the number of bytes left until the nearest limit on the

stack is hit, or -1 if no limits are in place.

Returns current position relative to the beginning of the input stream.

Sets the maximum number of bytes that this CodedInputStream will read

before refusing to continue. To prevent servers from allocating enormous

amounts of memory to hold parsed messages, the maximum message length

should be limited to the shortest length that will not harm usability.

The default limit is INT_MAX (~2GB) and apps should set shorter limits

if possible. An error will always be printed to stderr if the limit is

reached.

Note: setting a limit less than the current read position is interpreted

as a limit on the current position.

This is unrelated to PushLimit()/PopLimit().

The Total Bytes Limit minus the Current Position, or -1 if the total bytes

limit is INT_MAX.

Sets the maximum recursion depth. The default is 100.

Increments the current recursion depth. Returns true if the depth is

under the limit, false if it has gone over.

Decrements the recursion depth if possible.

Decrements the recursion depth blindly. This is faster than

DecrementRecursionDepth(). It should be used only if all previous

increments to recursion depth were successful.

Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).

Using this can reduce code size and complexity in some cases. The caller

is expected to check that the second part of the result is non-negative (to

bail out if the depth of recursion is too high) and, if all is well, to

later pass the first part of the result to PopLimit() or similar.

Shorthand for PushLimit(ReadVarint32(

&length

) ? length : 0).

Helper that is equivalent to: {

bool result = ConsumedEntireMessage();

PopLimit(limit);

UnsafeDecrementRecursionDepth();

return result; }

Using this can reduce code size and complexity in some cases.

Do not use unless the current recursion depth is greater than zero.

Helper that is equivalent to: {

bool result = ConsumedEntireMessage();

PopLimit(limit);

return result; }

Using this can reduce code size and complexity in some cases.

Set the pool used to look up extensions. Most users do not need to call

this as the correct pool will be chosen automatically.

WARNING: It is very easy to misuse this. Carefully read the requirements

below. Do not use this unless you are sure you need it. Almost no one

does.

Let's say you are parsing a message into message object m, and you want

to take advantage of SetExtensionRegistry(). You must follow these

requirements:

The given DescriptorPool must contain m->GetDescriptor(). It is not

sufficient for it to simply contain a descriptor that has the same name

and content -- it must be the *exact object*. In other words:

assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==

m->GetDescriptor());

There are two ways to satisfy this requirement:

1) Use m->GetDescriptor()->pool() as the pool. This is generally useless

because this is the pool that would be used anyway if you didn't call

SetExtensionRegistry() at all.

2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an

"underlay". Read the documentation for DescriptorPool for more

information about underlays.

You must also provide a MessageFactory. This factory will be used to

construct Message objects representing extensions. The factory's

GetPrototype() MUST return non-NULL for any Descriptor which can be found

through the provided pool.

If the provided factory might return instances of protocol-compiler-

generated (i.e. compiled-in) types, or if the outer message object m is

a generated type, then the given factory MUST have this property: If

GetPrototype() is given a Descriptor which resides in

DescriptorPool::generated_pool(), the factory MUST return the same

prototype which MessageFactory::generated_factory() would return. That

is, given a descriptor for a generated type, the factory must return an

instance of the generated class (NOT DynamicMessage). However, when

given a descriptor for a type that is NOT in generated_pool, the factory

is free to return any implementation.

The reason for this requirement is that generated sub-objects may be

accessed via the standard (non-reflection) extension accessor methods,

and these methods will down-cast the object to the generated class type.

If the object is not actually of that type, the results would be undefined.

On the other hand, if an extension is not compiled in, then there is no

way the code could end up accessing it via the standard accessors -- the

only way to access the extension is via reflection. When using reflection,

DynamicMessage and generated messages are indistinguishable, so it's fine

if these objects are represented using DynamicMessage.

Using DynamicMessageFactory on which you have called

SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the

above requirement.

If either pool or factory is NULL, both must be NULL.

Note that this feature is ignored when parsing "lite" messages as they do

not have descriptors.

Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool

has been provided.

Get the MessageFactory set via SetExtensionRegistry(), or NULL if no

factory has been provided.