Fill the message with a protocol buffer parsed from the given input stream.

Returns false on a read error or if the input is in the wrong format.

Read a protocol buffer from the given zero-copy input stream.

If successful, the entire input will be consumed.

Read a protocol buffer from the given zero-copy input stream, expecting the message to be exactly "size" bytes long.

If successful, exactly this many bytes will have been consumed from the input.

Reads a protocol buffer from the stream and merges it into this Message.

Singular fields read from the input overwrite what is already in the Message and repeated fields are appended to those already present.

It is the responsibility of the caller to call input->LastTagWas() (for groups) or input->ConsumedEntireMessage() (for non-groups) after this returns to verify that the message's end was delimited correctly.

ParsefromCodedStream() is implemented as Clear() followed by MergeFromCodedStream().

Like MergeFromCodedStream(), but succeeds even if required fields are missing in the input.

MergeFromCodedStream() is just implemented as MergePartialFromCodedStream() followed by IsInitialized().

Write a protocol buffer of this message to the given output.

Returns false on a write error. If the message is missing required fields, this may GOOGLE_CHECK-fail.

Write the message to the given zero-copy output stream.

All required fields must be set.

Serialize the message and store it in the given string.

All required fields must be set.

Serialize the message and store it in the given byte array.

All required fields must be set.

Make a string encoding the message.

Is equivalent to calling SerializeToString() on a string and using that. Returns the empty string if SerializeToString() would have returned an error. Note: If you intend to generate many such strings, you may reduce heap fragmentation by instead re-using the same string object with calls to SerializeToString().

Like SerializeToString(), but appends to the data to the string's existing contents.

All required fields must be set.

Computes the serialized size of the message.

This recursively calls ByteSize() on all embedded messages. If a subclass does not override this, it MUST override SetCachedSize().

Serializes the message without recomputing the size.

The message must not have changed since the last call to ByteSize(); if it has, the results are undefined.

Like SerializeWithCachedSizes, but writes directly to *target, returning a pointer to the byte immediately after the last byte written.

"target" must point at a byte array of at least ByteSize() bytes.

Returns the result of the last call to ByteSize().

An embedded message's size is needed both to serialize it (because embedded messages are length-delimited) and to compute the outer message's size. Caching the size avoids computing it multiple times.

ByteSize() does not automatically use the cached size when available because this would require invalidating it every time the message was modified, which would be too hard and expensive. (E.g. if a deeply-nested sub-message is changed, all of its parents' cached sizes would need to be invalidated, which is too much work for an otherwise inlined setter method.)

Construct a new instance of the same type.

Ownership is passed to the caller.

Clear all fields of the message and set them to their default values.

Clear() avoids freeing memory, assuming that any memory allocated to hold parts of the message will be needed again to hold the next message. If you actually want to free the memory used by a Message, you must delete it.

This is not implemented for Lite messages -- it just returns "(cannot determine missing fields for lite message)".

However, it is implemented for full messages. See message.h.

If |other| is the exact same class as this, calls MergeFrom().

Otherwise, results are undefined (probably crash).