Get a Descriptor for this message's type.

This describes what fields the message contains, the types of those fields, etc.

Get the Reflection interface for this Message, which can be used to read and modify the fields of the Message dynamically (in other words, without knowing the message type at compile time).

This object remains property of the Message.

Construct a new instance of the same type.

Ownership is passed to the caller.

Make this message into a copy of the given message.

The given message must have the same descriptor, but need not necessarily be the same class. By default this is just implemented as "Clear(); MergeFrom(from);".

Merge the fields from the given message into this message.

Singular fields will be overwritten, except for embedded messages which will be merged. Repeated fields will be concatenated. The given message must be of the same type as this message (i.e. the exact same class).

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.

Verifies that IsInitialized() returns true.

GOOGLE_CHECK-fails otherwise, with a nice error message.

Slowly build a list of all required fields that are not set.

This is much, much slower than IsInitialized() as it is implemented purely via reflection. Generally, you should not call this unless you have already determined that an error exists by calling IsInitialized().

Clears all unknown fields from this message and all embedded messages.

Normally, if unknown tag numbers are encountered when parsing a message, the tag and value are stored in the message's UnknownFieldSet and then written back out when the message is serialized. This allows servers which simply route messages to other servers to pass through messages that have new field definitions which they don't yet know about. However, this behavior can have security implications. To avoid it, call this method after parsing.

See Reflection::GetUnknownFields() for more on unknown fields.

Computes (an estimate of) the total number of bytes currently used for storing the message in memory.

The default implementation calls the Reflection object's SpaceUsed() method.

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.

Parse a protocol buffer from a file descriptor.

If successful, the entire input will be consumed.

Parse a protocol buffer from a C++ istream.

If successful, the entire input will be consumed.

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.

Serialize the message and write it to the given file descriptor.

All required fields must be set.

Serialize the message and write it to the given C++ ostream.

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.)

Get the UnknownFieldSet for the message.

This contains fields which were seen when the Message was parsed but were not recognized according to the Message's definition.

Get a mutable pointer to the UnknownFieldSet for the message.

This contains fields which were seen when the Message was parsed but were not recognized according to the Message's definition.

List all fields of the message which are currently set.

This includes extensions. Singular fields will only be listed if HasField(field) would return true and repeated fields will only be listed if FieldSize(field) would return non-zero. Fields (both normal fields and extension fields) will be listed ordered by field number.

Get a string value without copying, if possible.

GetString() necessarily returns a copy of the string. This can be inefficient when the string is already stored in a string object in the underlying message. GetStringReference() will return a reference to the underlying string in this case. Otherwise, it will copy the string into scratch and return that.

Note: It is perfectly reasonable and useful to write code like:

str = reflection->GetStringReference(field, &str);

This line would ensure that only one copy of the string is made regardless of the field's underlying representation. When initializing a newly-constructed string, though, it's just as fast and more readable to use code like:

string str = reflection->GetString(field);

Try to find an extension of this message type by fully-qualified field name.

Returns NULL if no extension is known for this name or number.

Try to find an extension of this message type by field number.

Returns NULL if no extension is known for this name or number.

Given a Descriptor, gets or constructs the default (prototype) Message of that type.

You can then call that message's New() method to construct a mutable message of that type.

Calling this method twice with the same Descriptor returns the same object. The returned object remains property of the factory. Also, any objects created by calling the prototype's New() method share some data with the prototype, so these must be destoyed before the MessageFactory is destroyed.

The given descriptor must outlive the returned message, and hence must outlive the MessageFactory.

Some implementations do not support all types. GetPrototype() will return NULL if the descriptor passed in is not supported.

This method may or may not be thread-safe depending on the implementation. Each implementation should document its own degree thread-safety.

Gets a MessageFactory which supports all generated, compiled-in messages.

In other words, for any compiled-in type FooMessage, the following is true:

MessageFactory::generated_factory()->GetPrototype(
  FooMessage::descriptor()) == FooMessage::default_instance()

This factory supports all types which are found in DescriptorPool::generated_pool(). If given a descriptor from any other pool, GetPrototype() will return NULL. (You can also check if a descriptor is for a generated message by checking if descriptor->file()->pool() == DescriptorPool::generated_pool().)

This factory is 100% thread-safe; calling GetPrototype() does not modify any shared data.

This factory is a singleton. The caller must not delete the object.

For internal use only: Registers a .proto file at static initialization time, to be placed in generated_factory.

The first time GetPrototype() is called with a descriptor from this file, |register_messages| will be called. It must call InternalRegisterGeneratedMessage() (below) to register each message type in the file. This strange mechanism is necessary because descriptors are built lazily, so we can't register types by their descriptor until we know that the descriptor exists.

For internal use only: Registers a message type.

Called only by the functions which are registered with InternalRegisterGeneratedFile(), above.