Google.Protobuf Provides a utility routine to copy small arrays much more quickly than Buffer.BlockCopy The threshold above which you should use Buffer.BlockCopy rather than ByteArray.Copy Determines which copy routine to use based on the number of bytes to be copied. Reverses the order of bytes in the array Immutable array of bytes. Unsafe operations that can cause IO Failure and/or other catestrophic side-effects. Constructs a new ByteString from the given byte array. The array is *not* copied, and must not be modified after this constructor is called. Provides direct, unrestricted access to the bytes contained in this instance. You must not modify or resize the byte array returned by this method. Internal use only. Ensure that the provided array is not mutated and belongs to this instance. Constructs a new ByteString from the given byte array. The array is *not* copied, and must not be modified after this constructor is called. Returns an empty ByteString. Returns the length of this ByteString in bytes. Returns true if this byte string is empty, false otherwise. Converts this into a byte array. The data is copied - changes to the returned array will not be reflected in this ByteString. A byte array with the same data as this ByteString. Converts this into a standard base64 representation. A base64 representation of this ByteString. Constructs a from the Base64 Encoded String. Constructs a from the given array. The contents are copied, so further modifications to the array will not be reflected in the returned ByteString. This method can also be invoked in ByteString.CopyFrom(0xaa, 0xbb, ...) form which is primarily useful for testing. Constructs a from a portion of a byte array. Creates a new by encoding the specified text with the given encoding. Creates a new by encoding the specified text in UTF-8. Retuns the byte at the given index. Converts this into a string by applying the given encoding. This method should only be used to convert binary data which was the result of encoding text with the given encoding. The encoding to use to decode the binary data into text. The result of decoding the binary data with the given decoding. Converts this into a string by applying the UTF-8 encoding. This method should only be used to convert binary data which was the result of encoding text with UTF-8. The result of decoding the binary data with the given decoding. Returns an iterator over the bytes in this . An iterator over the bytes in this object. Returns an iterator over the bytes in this . An iterator over the bytes in this object. Creates a CodedInputStream from this ByteString's data. Compares two byte strings for equality. The first byte string to compare. The second byte string to compare. true if the byte strings are equal; false otherwise. Compares two byte strings for inequality. The first byte string to compare. The second byte string to compare. false if the byte strings are equal; true otherwise. Compares this byte string with another object. The object to compare this with. true if refers to an equal ; false otherwise. Returns a hash code for this object. Two equal byte strings will return the same hash code. A hash code for this object. Compares this byte string with another. The to compare this with. true if refers to an equal byte string; false otherwise. Used internally by CodedOutputStream to avoid creating a copy for the write Copies the entire byte array to the destination array provided at the offset specified. Writes the entire byte array to the provided stream Reads and decodes protocol message fields. This class is generally used by generated code to read appropriate primitives from the stream. It effectively encapsulates the lowest levels of protocol buffer format. Repeated fields and map fields are not handled by this class; use and to serialize such fields. Whether to leave the underlying stream open when disposing of this stream. This is always true when there's no stream. Buffer of data read from the stream or provided at construction time. The index of the buffer at which we need to refill from the stream (if there is one). The position within the current buffer (i.e. the next byte to read) The stream to read further input from, or null if the byte array buffer was provided directly on construction, with no further data available. The last tag we read. 0 indicates we've read to the end of the stream (or haven't read anything yet). The next tag, used to store the value read by PeekTag. The total number of bytes read before the current buffer. The total bytes read up to the current position can be computed as totalBytesRetired + bufferPos. The absolute position of the end of the current message. Creates a new CodedInputStream reading data from the given byte array. Creates a new that reads from the given byte array slice. Creates a new reading data from the given stream, which will be disposed when the returned object is disposed. The stream to read from. Creates a new reading data from the given stream. The stream to read from. true to leave open when the returned is disposed; false to dispose of the given stream when the returned object is disposed. Creates a new CodedInputStream reading data from the given stream and buffer, using the default limits. Creates a new CodedInputStream reading data from the given stream and buffer, using the specified limits. This chains to the version with the default limits instead of vice versa to avoid having to check that the default values are valid every time. Creates a with the specified size and recursion limits, reading from an input stream. This method exists separately from the constructor to reduce the number of constructor overloads. It is likely to be used considerably less frequently than the constructors, as the default limits are suitable for most use cases. The input stream to read from The total limit of data to read from the stream. The maximum recursion depth to allow while reading. A CodedInputStream reading from with the specified size and recursion limits. Returns the current position in the input stream, or the position in the input buffer Returns the last tag read, or 0 if no tags have been read or we've read beyond the end of the stream. Returns the size limit for this stream. This limit is applied when reading from the underlying stream, as a sanity check. It is not applied when reading from a byte array data source without an underlying stream. The default value is 64MB. The size limit. Returns the recursion limit for this stream. This limit is applied whilst reading messages, to avoid maliciously-recursive data. The default limit is 64. The recursion limit for this stream. Disposes of this instance, potentially closing any underlying stream. As there is no flushing to perform here, disposing of a which was constructed with the leaveOpen option parameter set to true (or one which was constructed to read from a byte array) has no effect. Verifies that the last call to ReadTag() returned tag 0 - in other words, we've reached the end of the stream when we expected to. The tag read was not the one specified Peeks at the next field tag. This is like calling , but the tag is not consumed. (So a subsequent call to will return the same value.) Reads a field tag, returning the tag of 0 for "end of stream". If this method returns 0, it doesn't necessarily mean the end of all the data in this CodedInputStream; it may be the end of the logical stream for an embedded message, for example. The next field tag, or 0 for end of stream. (0 is never a valid tag.) Skips the data for the field with the tag we've just read. This should be called directly after , when the caller wishes to skip an unknown field. This method throws if the last-read tag was an end-group tag. If a caller wishes to skip a group, they should skip the whole group, by calling this method after reading the start-group tag. This behavior allows callers to call this method on any field they don't understand, correctly resulting in an error if an end-group tag has not been paired with an earlier start-group tag. The last tag was an end-group tag The last read operation read to the end of the logical stream Reads a double field from the stream. Reads a float field from the stream. Reads a uint64 field from the stream. Reads an int64 field from the stream. Reads an int32 field from the stream. Reads a fixed64 field from the stream. Reads a fixed32 field from the stream. Reads a bool field from the stream. Reads a string field from the stream. Reads an embedded message field value from the stream. Reads a bytes field value from the stream. Reads a uint32 field value from the stream. Reads an enum field value from the stream. Reads an sfixed32 field value from the stream. Reads an sfixed64 field value from the stream. Reads an sint32 field value from the stream. Reads an sint64 field value from the stream. Reads a length for length-delimited data. This is internally just reading a varint, but this method exists to make the calling code clearer. Peeks at the next tag in the stream. If it matches , the tag is consumed and the method returns true; otherwise, the stream is left in the original position and the method returns false. Same code as ReadRawVarint32, but read each byte individually, checking for buffer overflow. Reads a raw Varint from the stream. If larger than 32 bits, discard the upper bits. This method is optimised for the case where we've got lots of data in the buffer. That means we can check the size just once, then just read directly from the buffer without constant rechecking of the buffer length. Reads a varint from the input one byte at a time, so that it does not read any bytes after the end of the varint. If you simply wrapped the stream in a CodedInputStream and used ReadRawVarint32(Stream) then you would probably end up reading past the end of the varint since CodedInputStream buffers its input. Reads a raw varint from the stream. Reads a 32-bit little-endian integer from the stream. Reads a 64-bit little-endian integer from the stream. Decode a 32-bit value with ZigZag encoding. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.) Decode a 32-bit value with ZigZag encoding. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.) Sets currentLimit to (current position) + byteLimit. This is called when descending into a length-delimited embedded message. The previous limit is returned. The old limit. Discards the current limit, returning the previous limit. Returns whether or not all the data before the limit has been read. Returns true if the stream has reached the end of the input. This is the case if either the end of the underlying input source has been reached or the stream has reached a limit created using PushLimit. Called when buffer is empty to read more bytes from the input. If is true, RefillBuffer() gurantees that either there will be at least one byte in the buffer when it returns or it will throw an exception. If is false, RefillBuffer() returns false if no more bytes were available. Read one byte from the input. the end of the stream or the current limit was reached Reads a fixed size of bytes from the input. the end of the stream or the current limit was reached Reads and discards bytes. the end of the stream or the current limit was reached Abstraction of skipping to cope with streams which can't really skip. Encodes and writes protocol message fields. This class is generally used by generated code to write appropriate primitives to the stream. It effectively encapsulates the lowest levels of protocol buffer format. Unlike some other implementations, this does not include combined "write tag and value" methods. Generated code knows the exact byte representations of the tags they're going to write, so there's no need to re-encode them each time. Manually-written code calling this class should just call one of the WriteTag overloads before each value. Repeated fields and map fields are not handled by this class; use RepeatedField<T> and MapField<TKey, TValue> to serialize such fields. Computes the number of bytes that would be needed to encode a double field, including the tag. Computes the number of bytes that would be needed to encode a float field, including the tag. Computes the number of bytes that would be needed to encode a uint64 field, including the tag. Computes the number of bytes that would be needed to encode an int64 field, including the tag. Computes the number of bytes that would be needed to encode an int32 field, including the tag. Computes the number of bytes that would be needed to encode a fixed64 field, including the tag. Computes the number of bytes that would be needed to encode a fixed32 field, including the tag. Computes the number of bytes that would be needed to encode a bool field, including the tag. Computes the number of bytes that would be needed to encode a string field, including the tag. Computes the number of bytes that would be needed to encode a group field, including the tag. Computes the number of bytes that would be needed to encode an embedded message field, including the tag. Computes the number of bytes that would be needed to encode a bytes field, including the tag. Computes the number of bytes that would be needed to encode a uint32 field, including the tag. Computes the number of bytes that would be needed to encode a enum field, including the tag. The caller is responsible for converting the enum value to its numeric value. Computes the number of bytes that would be needed to encode an sfixed32 field, including the tag. Computes the number of bytes that would be needed to encode an sfixed64 field, including the tag. Computes the number of bytes that would be needed to encode an sint32 field, including the tag. Computes the number of bytes that would be needed to encode an sint64 field, including the tag. Computes the number of bytes that would be needed to encode a length, as written by . Computes the number of bytes that would be needed to encode a varint. Computes the number of bytes that would be needed to encode a varint. Computes the number of bytes that would be needed to encode a tag. The buffer size used by CreateInstance(Stream). Creates a new CodedOutputStream that writes directly to the given byte array. If more bytes are written than fit in the array, OutOfSpaceException will be thrown. Creates a new CodedOutputStream that writes directly to the given byte array slice. If more bytes are written than fit in the array, OutOfSpaceException will be thrown. Creates a new which write to the given stream, and disposes of that stream when the returned CodedOutputStream is disposed. The stream to write to. It will be disposed when the returned CodedOutputStream is disposed. Creates a new CodedOutputStream which write to the given stream and uses the specified buffer size. The stream to write to. It will be disposed when the returned CodedOutputStream is disposed. The size of buffer to use internally. Creates a new CodedOutputStream which write to the given stream. The stream to write to. If true, is left open when the returned CodedOutputStream is disposed; if false, the provided stream is disposed as well. Creates a new CodedOutputStream which write to the given stream and uses the specified buffer size. The stream to write to. The size of buffer to use internally. If true, is left open when the returned CodedOutputStream is disposed; if false, the provided stream is disposed as well. Returns the current position in the stream, or the position in the output buffer Writes a double field value, without a tag, to the stream. The value to write Writes a float field value, without a tag, to the stream. The value to write Writes a uint64 field value, without a tag, to the stream. The value to write Writes an int64 field value, without a tag, to the stream. The value to write Writes an int32 field value, without a tag, to the stream. The value to write Writes a fixed64 field value, without a tag, to the stream. The value to write Writes a fixed32 field value, without a tag, to the stream. The value to write Writes a bool field value, without a tag, to the stream. The value to write Writes a string field value, without a tag, to the stream. The data is length-prefixed. The value to write Writes a message, without a tag, to the stream. The data is length-prefixed. The value to write Write a byte string, without a tag, to the stream. The data is length-prefixed. The value to write Writes a uint32 value, without a tag, to the stream. The value to write Writes an enum value, without a tag, to the stream. The value to write Writes an sfixed32 value, without a tag, to the stream. The value to write. Writes an sfixed64 value, without a tag, to the stream. The value to write Writes an sint32 value, without a tag, to the stream. The value to write Writes an sint64 value, without a tag, to the stream. The value to write Writes a length (in bytes) for length-delimited data. This method simply writes a rawint, but exists for clarity in calling code. Length value, in bytes. Encodes and writes a tag. The number of the field to write the tag for The wire format type of the tag to write Writes an already-encoded tag. The encoded tag Writes the given single-byte tag directly to the stream. The encoded tag Writes the given two-byte tag directly to the stream. The first byte of the encoded tag The second byte of the encoded tag Writes the given three-byte tag directly to the stream. The first byte of the encoded tag The second byte of the encoded tag The third byte of the encoded tag Writes the given four-byte tag directly to the stream. The first byte of the encoded tag The second byte of the encoded tag The third byte of the encoded tag The fourth byte of the encoded tag Writes the given five-byte tag directly to the stream. The first byte of the encoded tag The second byte of the encoded tag The third byte of the encoded tag The fourth byte of the encoded tag The fifth byte of the encoded tag Writes a 32 bit value as a varint. The fast route is taken when there's enough buffer space left to whizz through without checking for each byte; otherwise, we resort to calling WriteRawByte each time. Writes out an array of bytes. Writes out part of an array of bytes. Encode a 32-bit value with ZigZag encoding. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.) Encode a 64-bit value with ZigZag encoding. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.) Indicates that a CodedOutputStream wrapping a flat byte array ran out of space. Flushes any buffered data and optionally closes the underlying stream, if any. By default, any underlying stream is closed by this method. To configure this behaviour, use a constructor overload with a leaveOpen parameter. If this instance does not have an underlying stream, this method does nothing. For the sake of efficiency, calling this method does not prevent future write calls - but if a later write ends up writing to a stream which has been disposed, that is likely to fail. It is recommend that you not call any other methods after this. Flushes any buffered data to the underlying stream (if there is one). Verifies that SpaceLeft returns zero. It's common to create a byte array that is exactly big enough to hold a message, then write to it with a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that the message was actually as big as expected, which can help bugs. If writing to a flat array, returns the space left in the array. Otherwise, throws an InvalidOperationException. Representation of a map field in a Protocol Buffer message. Key type in the map. Must be a type supported by Protocol Buffer map keys. Value type in the map. Must be a type supported by Protocol Buffers. For string keys, the equality comparison is provided by . Null values are not permitted in the map, either for wrapper types or regular messages. If a map is deserialized from a data stream and the value is missing from an entry, a default value is created instead. For primitive types, that is the regular default value (0, the empty string and so on); for message types, an empty instance of the message is created, as if the map entry contained a 0-length encoded value for the field. This implementation does not generally prohibit the use of key/value types which are not supported by Protocol Buffers (e.g. using a key type of byte) but nor does it guarantee that all operations will work in such cases. The order in which entries are returned when iterating over this object is undefined, and may change in future versions. Creates a deep clone of this object. A deep clone of this object. Adds the specified key/value pair to the map. This operation fails if the key already exists in the map. To replace an existing entry, use the indexer. The key to add The value to add. The given key already exists in map. Determines whether the specified key is present in the map. The key to check. true if the map contains the given key; false otherwise. Removes the entry identified by the given key from the map. The key indicating the entry to remove from the map. true if the map contained the given key before the entry was removed; false otherwise. Gets the value associated with the specified key. The key whose value to get. When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the parameter. This parameter is passed uninitialized. true if the map contains an element with the specified key; otherwise, false. Gets or sets the value associated with the specified key. The key of the value to get or set. The property is retrieved and key does not exist in the collection. The value associated with the specified key. If the specified key is not found, a get operation throws a , and a set operation creates a new element with the specified key. Gets a collection containing the keys in the map. Gets a collection containing the values in the map. Adds the specified entries to the map. The keys and values are not automatically cloned. The entries to add to the map. Returns an enumerator that iterates through the collection. An enumerator that can be used to iterate through the collection. Returns an enumerator that iterates through a collection. An object that can be used to iterate through the collection. Adds the specified item to the map. The item to add to the map. Removes all items from the map. Determines whether map contains an entry equivalent to the given key/value pair. The key/value pair to find. Copies the key/value pairs in this map to an array. The array to copy the entries into. The index of the array at which to start copying values. Removes the specified key/value pair from the map. Both the key and the value must be found for the entry to be removed. The key/value pair to remove. true if the key/value pair was found and removed; false otherwise. Gets the number of elements contained in the map. Gets a value indicating whether the map is read-only. Determines whether the specified , is equal to this instance. The to compare with this instance. true if the specified is equal to this instance; otherwise, false. Returns a hash code for this instance. A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. Compares this map with another for equality. The order of the key/value pairs in the maps is not deemed significant in this comparison. The map to compare this with. true if refers to an equal map; false otherwise. Adds entries to the map from the given stream. It is assumed that the stream is initially positioned after the tag specified by the codec. This method will continue reading entries from the stream until the end is reached, or a different tag is encountered. Stream to read from Codec describing how the key/value pairs are encoded Writes the contents of this map to the given coded output stream, using the specified codec to encode each entry. The output stream to write to. The codec to use for each entry. Calculates the size of this map based on the given entry codec. The codec to use to encode each entry. Returns a string representation of this repeated field, in the same way as it would be represented by the default JSON formatter. A codec for a specific map field. This contains all the information required to encode and decode the nested messages. Creates a new entry codec based on a separate key codec and value codec, and the tag to use for each map entry. The key codec. The value codec. The map tag to use to introduce each map entry. The tag used in the enclosing message to indicate map entries. A mutable message class, used for parsing and serializing. This delegates the work to a codec, but implements the interface for interop with and . This is nested inside Codec as it's tightly coupled to the associated codec, and it's simpler if it has direct access to all its fields. Read-only wrapper around another dictionary. The contents of a repeated field: essentially, a collection with some extra restrictions (no null values) and capabilities (deep cloning). This implementation does not generally prohibit the use of types which are not supported by Protocol Buffers but nor does it guarantee that all operations will work in such cases. The element type of the repeated field. Creates a deep clone of this repeated field. If the field type is a message type, each element is also cloned; otherwise, it is assumed that the field type is primitive (including string and bytes, both of which are immutable) and so a simple copy is equivalent to a deep clone. A deep clone of this repeated field. Adds the entries from the given input stream, decoding them with the specified codec. The input stream to read from. The codec to use in order to read each entry. Calculates the size of this collection based on the given codec. The codec to use when encoding each field. The number of bytes that would be written to a by , using the same codec. Writes the contents of this collection to the given , encoding each value using the specified codec. The output stream to write to. The codec to use when encoding each value. Adds the specified item to the collection. The item to add. Removes all items from the collection. Determines whether this collection contains the given item. The item to find. true if this collection contains the given item; false otherwise. Copies this collection to the given array. The array to copy to. The first index of the array to copy to. Removes the specified item from the collection The item to remove. true if the item was found and removed; false otherwise. Gets the number of elements contained in the collection. Gets a value indicating whether the collection is read-only. Adds all of the specified values into this collection. The values to add to this collection. Adds all of the specified values into this collection. This method is present to allow repeated fields to be constructed from queries within collection initializers. Within non-collection-initializer code, consider using the equivalent method instead for clarity. The values to add to this collection. Returns an enumerator that iterates through the collection. An enumerator that can be used to iterate through the collection. Determines whether the specified , is equal to this instance. The to compare with this instance. true if the specified is equal to this instance; otherwise, false. Returns an enumerator that iterates through a collection. An object that can be used to iterate through the collection. Returns a hash code for this instance. A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. Compares this repeated field with another for equality. The repeated field to compare this with. true if refers to an equal repeated field; false otherwise. Returns the index of the given item within the collection, or -1 if the item is not present. The item to find in the collection. The zero-based index of the item, or -1 if it is not found. Inserts the given item at the specified index. The index at which to insert the item. The item to insert. Removes the item at the given index. The zero-based index of the item to remove. Returns a string representation of this repeated field, in the same way as it would be represented by the default JSON formatter. Gets or sets the item at the specified index. The element at the specified index. The zero-based index of the element to get or set. The item at the specified index. Extension methods for , effectively providing the familiar members from previous desktop framework versions while targeting the newer releases, .NET Core etc. Returns the public getter of a property, or null if there is no such getter (either because it's read-only, or the getter isn't public). Returns the public setter of a property, or null if there is no such setter (either because it's write-only, or the setter isn't public). Factory methods for . Retrieves a codec suitable for a string field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a bytes field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a bool field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an int32 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an sint32 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a fixed32 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an sfixed32 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a uint32 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an int64 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an sint64 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a fixed64 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an sfixed64 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a uint64 field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a float field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for a double field with the given tag. The tag. A codec for the given tag. Retrieves a codec suitable for an enum field with the given tag. The tag. A conversion function from to the enum type. A conversion function from the enum type to . A codec for the given tag. Retrieves a codec suitable for a message field with the given tag. The tag. A parser to use for the message type. A codec for the given tag. Creates a codec for a wrapper type of a class - which must be string or ByteString. Creates a codec for a wrapper type of a struct - which must be Int32, Int64, UInt32, UInt64, Bool, Single or Double. Helper code to create codecs for wrapper types. Somewhat ugly with all the static methods, but the conversions involved to/from nullable types make it slightly tricky to improve. So long as we keep the public API (ForClassWrapper, ForStructWrapper) in place, we can refactor later if we come up with something cleaner. Returns a field codec which effectively wraps a value of type T in a message. An encode/decode pair for a single field. This effectively encapsulates all the information needed to read or write the field value from/to a coded stream. This class is public and has to be as it is used by generated code, but its public API is very limited - just what the generated code needs to call directly. This never writes default values to the stream, and does not address "packedness" in repeated fields itself, other than to know whether or not the field *should* be packed. Returns a delegate to write a value (unconditionally) to a coded output stream. Returns the size calculator for just a value. Returns a delegate to read a value from a coded input stream. It is assumed that the stream is already positioned on the appropriate tag. Returns the fixed size for an entry, or 0 if sizes vary. Gets the tag of the codec. The tag of the codec. Default value for this codec. Usually the same for every instance of the same type, but for string/ByteString wrapper fields the codec's default value is null, whereas for other string/ByteString fields it's "" or ByteString.Empty. The default value of the codec's type. Write a tag and the given value, *if* the value is not the default. Reads a value of the codec type from the given . The input stream to read from. The value read from the stream. Calculates the size required to write the given value, with a tag, if the value is not the default. Class containing helpful workarounds for various platform compatibility A message type that has a custom string format for diagnostic purposes. Calling on a generated message type normally returns the JSON representation. If a message type implements this interface, then the method will be called instead of the regular JSON formatting code, but only when ToString() is called either on the message itself or on another message which contains it. This does not affect the normal JSON formatting of the message. For example, if you create a proto message representing a GUID, the internal representation may be a bytes field or four fixed32 fields. However, when debugging it may be more convenient to see a result in the same format as provides. This interface extends to avoid it accidentally being implemented on types other than messages, where it would not be used by anything in the framework. Returns a string representation of this object, for diagnostic purposes. This method is called when a message is formatted as part of a call. It does not affect the JSON representation used by other than in calls to . While it is recommended that the result is valid JSON, this is never assumed by the Protobuf library. A string representation of this object, for diagnostic purposes. Generic interface for a deeply cloneable type. All generated messages implement this interface, but so do some non-message types. Additionally, due to the type constraint on T in , it is simpler to keep this as a separate interface. The type itself, returned by the method. Creates a deep clone of this object. A deep clone of this object. Interface for a Protocol Buffers message, supporting basic operations required for serialization. Merges the data from the specified coded input stream with the current message. See the user guide for precise merge semantics. Writes the data to the given coded output stream. Coded output stream to write the data to. Must not be null. Calculates the size of this message in Protocol Buffer wire format, in bytes. The number of bytes required to write this message to a coded output stream. Descriptor for this message. All instances are expected to return the same descriptor, and for generated types this will be an explicitly-implemented member, returning the same value as the static property declared on the type. Generic interface for a Protocol Buffers message, where the type parameter is expected to be the same type as the implementation class. The message type. Merges the given message into this one. See the user guide for precise merge semantics. The message to merge with this one. Must not be null. Thrown when an attempt is made to parse invalid JSON, e.g. using a non-string property key, or including a redundant comma. Parsing a protocol buffer message represented in JSON using can throw both this exception and depending on the situation. This exception is only thrown for "pure JSON" errors, whereas InvalidProtocolBufferException is thrown when the JSON may be valid in and of itself, but cannot be parsed as a protocol buffer message. Thrown when a protocol message being parsed is invalid in some way, e.g. it contains a malformed varint or a negative byte length. Creates an exception for an error condition of an invalid tag being encountered. Reflection-based converter from messages to JSON. Instances of this class are thread-safe, with no mutable state. This is a simple start to get JSON formatting working. As it's reflection-based, it's not as quick as baking calls into generated messages - but is a simpler implementation. (This code is generally not heavily optimized.) Returns a formatter using the default settings. The JSON representation of the first 160 characters of Unicode. Empty strings are replaced by the static constructor. Creates a new formatted with the given settings. The settings. Formats the specified message as JSON. The message to format. The formatted message. Formats the specified message as JSON. The message to format. The TextWriter to write the formatted message to. The formatted message. Converts a message to JSON for diagnostic purposes with no extra context. This differs from calling on the default JSON formatter in its handling of . As no type registry is available in calls, the normal way of resolving the type of an Any message cannot be applied. Instead, a JSON property named @value is included with the base64 data from the property of the message. The value returned by this method is only designed to be used for diagnostic purposes. It may not be parsable by , and may not be parsable by other Protocol Buffer implementations. The message to format for diagnostic purposes. The diagnostic-only JSON representation of the message Camel-case converter with added strictness for field mask formatting. The field mask is invalid for JSON representation Writes a single value to the given writer as JSON. Only types understood by Protocol Buffers can be written in this way. This method is only exposed for advanced use cases; most users should be using or . The writer to write the value to. Must not be null. The value to write. May be null. Central interception point for well-known type formatting. Any well-known types which don't need special handling can fall back to WriteMessage. We avoid assuming that the values are using the embedded well-known types, in order to allow for dynamic messages in the future. Writes a string (including leading and trailing double quotes) to a builder, escaping as required. Other than surrogate pair handling, this code is mostly taken from src/google/protobuf/util/internal/json_escaping.cc. Settings controlling JSON formatting. Default settings, as used by Whether fields whose values are the default for the field type (e.g. 0 for integers) should be formatted (true) or omitted (false). The type registry used to format messages. Creates a new object with the specified formatting of default values and an empty type registry. true if default values (0, empty strings etc) should be formatted; false otherwise. Creates a new object with the specified formatting of default values and type registry. true if default values (0, empty strings etc) should be formatted; false otherwise. The to use when formatting messages. Reflection-based converter from JSON to messages. Instances of this class are thread-safe, with no mutable state. This is a simple start to get JSON parsing working. As it's reflection-based, it's not as quick as baking calls into generated messages - but is a simpler implementation. (This code is generally not heavily optimized.) Returns a formatter using the default settings. Creates a new formatted with the given settings. The settings. Parses and merges the information into the given message. The message to merge the JSON information into. The JSON to parse. Parses JSON read from and merges the information into the given message. The message to merge the JSON information into. Reader providing the JSON to parse. Merges the given message using data from the given tokenizer. In most cases, the next token should be a "start object" token, but wrapper types and nullity can invalidate that assumption. This is implemented as an LL(1) recursive descent parser over the stream of tokens provided by the tokenizer. This token stream is assumed to be valid JSON, with the tokenizer performing that validation - but not every token stream is valid "protobuf JSON". Parses into a new message. The type of message to create. The JSON to parse. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly Parses JSON read from into a new message. The type of message to create. Reader providing the JSON to parse. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly Parses into a new message. The JSON to parse. Descriptor of message type to parse. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly Parses JSON read from into a new message. Reader providing the JSON to parse. Descriptor of message type to parse. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly Creates a new instance of the message type for the given field. Checks that any infinite/NaN values originated from the correct text. This corrects the lenient whitespace handling of double.Parse/float.Parse, as well as the way that Mono parses out-of-range values as infinity. Settings controlling JSON parsing. Default settings, as used by . This has the same default recursion limit as , and an empty type registry. The maximum depth of messages to parse. Note that this limit only applies to parsing messages, not collections - so a message within a collection within a message only counts as depth 2, not 3. The type registry used to parse messages. Creates a new object with the specified recursion limit. The maximum depth of messages to parse Creates a new object with the specified recursion limit and type registry. The maximum depth of messages to parse The type registry used to parse messages Simple but strict JSON tokenizer, rigidly following RFC 7159. This tokenizer is stateful, and only returns "useful" tokens - names, values etc. It does not create tokens for the separator between names and values, or for the comma between values. It validates the token stream as it goes - so callers can assume that the tokens it produces are appropriate. For example, it would never produce "start object, end array." Implementation details: the base class handles single token push-back and Not thread-safe. Creates a tokenizer that reads from the given text reader. Creates a tokenizer that first replays the given list of tokens, then continues reading from another tokenizer. Note that if the returned tokenizer is "pushed back", that does not push back on the continuation tokenizer, or vice versa. Care should be taken when using this method - it was created for the sake of Any parsing. Returns the depth of the stack, purely in objects (not collections). Informally, this is the number of remaining unclosed '{' characters we have. Returns the next JSON token in the stream. An EndDocument token is returned to indicate the end of the stream, after which point Next() should not be called again. This implementation provides single-token buffering, and calls if there is no buffered token. The next token in the stream. This is never null. This method is called after an EndDocument token has been returned The input text does not comply with RFC 7159 Returns the next JSON token in the stream, when requested by the base class. (The method delegates to this if it doesn't have a buffered token.) This method is called after an EndDocument token has been returned The input text does not comply with RFC 7159 Tokenizer which first exhausts a list of tokens, then consults another tokenizer. Tokenizer which does all the *real* work of parsing JSON. This method essentially just loops through characters skipping whitespace, validating and changing state (e.g. from ObjectBeforeColon to ObjectAfterColon) until it reaches something which will be a genuine token (e.g. a start object, or a value) at which point it returns the token. Although the method is large, it would be relatively hard to break down further... most of it is the large switch statement, which sometimes returns and sometimes doesn't. Reads a string token. It is assumed that the opening " has already been read. Reads an escaped character. It is assumed that the leading backslash has already been read. Reads an escaped Unicode 4-nybble hex sequence. It is assumed that the leading \u has already been read. Consumes a text-only literal, throwing an exception if the read text doesn't match it. It is assumed that the first letter of the literal has already been read. Validates that we're in a valid state to read a value (using the given error prefix if necessary) and changes the state to the appropriate one, e.g. ObjectAfterColon to ObjectAfterProperty. Pops the top-most container, and sets the state to the appropriate one for the end of a value in the parent container. Possible states of the tokenizer. This is a flags enum purely so we can simply and efficiently represent a set of valid states for checking. Each is documented with an example, where ^ represents the current position within the text stream. The examples all use string values, but could be any value, including nested objects/arrays. The complete state of the tokenizer also includes a stack to indicate the contexts (arrays/objects). Any additional notional state of "AfterValue" indicates that a value has been completed, at which point there's an immediate transition to ExpectedEndOfDocument, ObjectAfterProperty or ArrayAfterValue. These states were derived manually by reading RFC 7159 carefully. ^ { "foo": "bar" } Before the value in a document. Next states: ObjectStart, ArrayStart, "AfterValue" { "foo": "bar" } ^ After the value in a document. Next states: ReaderExhausted { "foo": "bar" } ^ (and already read to the end of the reader) Terminal state. { ^ "foo": "bar" } Before the *first* property in an object. Next states: "AfterValue" (empty object) ObjectBeforeColon (read a name) { "foo" ^ : "bar", "x": "y" } Next state: ObjectAfterColon { "foo" : ^ "bar", "x": "y" } Before any property other than the first in an object. (Equivalently: after any property in an object) Next states: "AfterValue" (value is simple) ObjectStart (value is object) ArrayStart (value is array) { "foo" : "bar" ^ , "x" : "y" } At the end of a property, so expecting either a comma or end-of-object Next states: ObjectAfterComma or "AfterValue" { "foo":"bar", ^ "x":"y" } Read the comma after the previous property, so expecting another property. This is like ObjectStart, but closing brace isn't valid here Next state: ObjectBeforeColon. [ ^ "foo", "bar" ] Before the *first* value in an array. Next states: "AfterValue" (read a value) "AfterValue" (end of array; will pop stack) [ "foo" ^ , "bar" ] After any value in an array, so expecting either a comma or end-of-array Next states: ArrayAfterComma or "AfterValue" [ "foo", ^ "bar" ] After a comma in an array, so there *must* be another value (simple or complex). Next states: "AfterValue" (simple value), StartObject, StartArray Wrapper around a text reader allowing small amounts of buffering and location handling. The buffered next character, if we have one. Returns the next character in the stream, or null if we have reached the end. Creates a new exception appropriate for the current state of the reader. Stream implementation which proxies another stream, only allowing a certain amount of data to be read. Note that this is only used to read delimited streams, so it doesn't attempt to implement everything. Extension methods on and . Merges data from the given byte array into an existing message. The message to merge the data into. The data to merge, which must be protobuf-encoded binary data. Merges data from the given byte string into an existing message. The message to merge the data into. The data to merge, which must be protobuf-encoded binary data. Merges data from the given stream into an existing message. The message to merge the data into. Stream containing the data to merge, which must be protobuf-encoded binary data. Merges length-delimited data from the given stream into an existing message. The stream is expected to contain a length and then the data. Only the amount of data specified by the length will be consumed. The message to merge the data into. Stream containing the data to merge, which must be protobuf-encoded binary data. Converts the given message into a byte array in protobuf encoding. The message to convert. The message data as a byte array. Writes the given message data to the given stream in protobuf encoding. The message to write to the stream. The stream to write to. Writes the length and then data of the given message to a stream. The message to write. The output stream to write to. Converts the given message into a byte string in protobuf encoding. The message to convert. The message data as a byte string. A general message parser, typically used by reflection-based code as all the methods return simple . Creates a template instance ready for population. An empty message. Parses a message from a byte array. The byte array containing the message. Must not be null. The newly parsed message. Parses a message from the given byte string. The data to parse. The parsed message. Parses a message from the given stream. The stream to parse. The parsed message. Parses a length-delimited message from the given stream. The stream is expected to contain a length and then the data. Only the amount of data specified by the length will be consumed. The stream to parse. The parsed message. Parses a message from the given coded input stream. The stream to parse. The parsed message. Parses a message from the given JSON. The JSON to parse. The parsed message. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly A parser for a specific message type.

This delegates most behavior to the implementation within the original type, but provides convenient overloads to parse from a variety of sources.

Most applications will never need to create their own instances of this type; instead, use the static Parser property of a generated message type to obtain a parser for that type.

The type of message to be parsed. Creates a new parser. The factory method is effectively an optimization over using a generic constraint to require a parameterless constructor: delegates are significantly faster to execute. Function to invoke when a new, empty message is required. Creates a template instance ready for population. An empty message. Parses a message from a byte array. The byte array containing the message. Must not be null. The newly parsed message. Parses a message from the given byte string. The data to parse. The parsed message. Parses a message from the given stream. The stream to parse. The parsed message. Parses a length-delimited message from the given stream. The stream is expected to contain a length and then the data. Only the amount of data specified by the length will be consumed. The stream to parse. The parsed message. Parses a message from the given coded input stream. The stream to parse. The parsed message. Parses a message from the given JSON. The JSON to parse. The parsed message. The JSON does not comply with RFC 7159 The JSON does not represent a Protocol Buffers message correctly Helper methods for throwing exceptions when preconditions are not met. This class is used internally and by generated code; it is not particularly expected to be used from application code, although nothing prevents it from being used that way. Throws an ArgumentNullException if the given value is null, otherwise return the value to the caller. Throws an ArgumentNullException if the given value is null, otherwise return the value to the caller. This is equivalent to but without the type parameter constraint. In most cases, the constraint is useful to prevent you from calling CheckNotNull with a value type - but it gets in the way if either you want to use it with a nullable value type, or you want to use it with an unconstrained type parameter. Holder for reflection information generated from google/protobuf/descriptor.proto File descriptor for google/protobuf/descriptor.proto The protocol compiler can output a FileDescriptorSet containing the .proto files it parses. Field number for the "file" field. Describes a complete .proto file. Field number for the "name" field. file name, relative to root of source tree Field number for the "package" field. e.g. "foo", "foo.bar", etc. Field number for the "dependency" field. Names of files imported by this file. Field number for the "public_dependency" field. Indexes of the public imported files in the dependency list above. Field number for the "weak_dependency" field. Indexes of the weak imported files in the dependency list. For Google-internal migration only. Do not use. Field number for the "message_type" field. All top-level definitions in this file. Field number for the "enum_type" field. Field number for the "service" field. Field number for the "extension" field. Field number for the "options" field. Field number for the "source_code_info" field. This field contains optional information about the original source code. You may safely remove this entire field without harming runtime functionality of the descriptors -- the information is needed only by development tools. Field number for the "syntax" field. The syntax of the proto file. The supported values are "proto2" and "proto3". Describes a message type. Field number for the "name" field. Field number for the "field" field. Field number for the "extension" field. Field number for the "nested_type" field. Field number for the "enum_type" field. Field number for the "extension_range" field. Field number for the "oneof_decl" field. Field number for the "options" field. Field number for the "reserved_range" field. Field number for the "reserved_name" field. Reserved field names, which may not be used by fields in the same message. A given name may only be reserved once. Container for nested types declared in the DescriptorProto message type. Field number for the "start" field. Field number for the "end" field. Range of reserved tag numbers. Reserved tag numbers may not be used by fields or extension ranges in the same message. Reserved ranges may not overlap. Field number for the "start" field. Inclusive. Field number for the "end" field. Exclusive. Describes a field within a message. Field number for the "name" field. Field number for the "number" field. Field number for the "label" field. Field number for the "type" field. If type_name is set, this need not be set. If both this and type_name are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. Field number for the "type_name" field. For message and enum types, this is the name of the type. If the name starts with a '.', it is fully-qualified. Otherwise, C++-like scoping rules are used to find the type (i.e. first the nested types within this message are searched, then within the parent, on up to the root namespace). Field number for the "extendee" field. For extensions, this is the name of the type being extended. It is resolved in the same manner as type_name. Field number for the "default_value" field. For numeric types, contains the original text representation of the value. For booleans, "true" or "false". For strings, contains the default text contents (not escaped in any way). For bytes, contains the C escaped value. All bytes >= 128 are escaped. TODO(kenton): Base-64 encode? Field number for the "oneof_index" field. If set, gives the index of a oneof in the containing type's oneof_decl list. This field is a member of that oneof. Field number for the "json_name" field. JSON name of this field. The value is set by protocol compiler. If the user has set a "json_name" option on this field, that option's value will be used. Otherwise, it's deduced from the field's name by converting it to camelCase. Field number for the "options" field. Container for nested types declared in the FieldDescriptorProto message type. 0 is reserved for errors. Order is weird for historical reasons. Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if negative values are likely. Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if negative values are likely. Tag-delimited aggregate. Length-delimited aggregate. New in version 2. Uses ZigZag encoding. Uses ZigZag encoding. 0 is reserved for errors TODO(sanjay): Should we add LABEL_MAP? Describes a oneof. Field number for the "name" field. Field number for the "options" field. Describes an enum type. Field number for the "name" field. Field number for the "value" field. Field number for the "options" field. Describes a value within an enum. Field number for the "name" field. Field number for the "number" field. Field number for the "options" field. Describes a service. Field number for the "name" field. Field number for the "method" field. Field number for the "options" field. Describes a method of a service. Field number for the "name" field. Field number for the "input_type" field. Input and output type names. These are resolved in the same way as FieldDescriptorProto.type_name, but must refer to a message type. Field number for the "output_type" field. Field number for the "options" field. Field number for the "client_streaming" field. Identifies if client streams multiple client messages Field number for the "server_streaming" field. Identifies if server streams multiple server messages Field number for the "java_package" field. Sets the Java package where classes generated from this .proto will be placed. By default, the proto package is used, but this is often inappropriate because proto packages do not normally start with backwards domain names. Field number for the "java_outer_classname" field. If set, all the classes from the .proto file are wrapped in a single outer class with the given name. This applies to both Proto1 (equivalent to the old "--one_java_file" option) and Proto2 (where a .proto always translates to a single class, but you may want to explicitly choose the class name). Field number for the "java_multiple_files" field. If set true, then the Java code generator will generate a separate .java file for each top-level message, enum, and service defined in the .proto file. Thus, these types will *not* be nested inside the outer class named by java_outer_classname. However, the outer class will still be generated to contain the file's getDescriptor() method as well as any top-level extensions defined in the file. Field number for the "java_generate_equals_and_hash" field. If set true, then the Java code generator will generate equals() and hashCode() methods for all messages defined in the .proto file. This increases generated code size, potentially substantially for large protos, which may harm a memory-constrained application. - In the full runtime this is a speed optimization, as the AbstractMessage base class includes reflection-based implementations of these methods. - In the lite runtime, setting this option changes the semantics of equals() and hashCode() to more closely match those of the full runtime; the generated methods compute their results based on field values rather than object identity. (Implementations should not assume that hashcodes will be consistent across runtimes or versions of the protocol compiler.) Field number for the "java_string_check_utf8" field. If set true, then the Java2 code generator will generate code that throws an exception whenever an attempt is made to assign a non-UTF-8 byte sequence to a string field. Message reflection will do the same. However, an extension field still accepts non-UTF-8 byte sequences. This option has no effect on when used with the lite runtime. Field number for the "optimize_for" field. Field number for the "go_package" field. Sets the Go package where structs generated from this .proto will be placed. If omitted, the Go package will be derived from the following: - The basename of the package import path, if provided. - Otherwise, the package statement in the .proto file, if present. - Otherwise, the basename of the .proto file, without extension. Field number for the "cc_generic_services" field. Should generic services be generated in each language? "Generic" services are not specific to any particular RPC system. They are generated by the main code generators in each language (without additional plugins). Generic services were the only kind of service generation supported by early versions of google.protobuf. Generic services are now considered deprecated in favor of using plugins that generate code specific to your particular RPC system. Therefore, these default to false. Old code which depends on generic services should explicitly set them to true. Field number for the "java_generic_services" field. Field number for the "py_generic_services" field. Field number for the "deprecated" field. Is this file deprecated? Depending on the target platform, this can emit Deprecated annotations for everything in the file, or it will be completely ignored; in the very least, this is a formalization for deprecating files. Field number for the "cc_enable_arenas" field. Enables the use of arenas for the proto messages in this file. This applies only to generated classes for C++. Field number for the "objc_class_prefix" field. Sets the objective c class prefix which is prepended to all objective c generated classes from this .proto. There is no default. Field number for the "csharp_namespace" field. Namespace for generated classes; defaults to the package. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Container for nested types declared in the FileOptions message type. Generated classes can be optimized for speed or code size. Generate complete code for parsing, serialization, etc. Generate code using MessageLite and the lite runtime. Field number for the "message_set_wire_format" field. Set true to use the old proto1 MessageSet wire format for extensions. This is provided for backwards-compatibility with the MessageSet wire format. You should not use this for any other reason: It's less efficient, has fewer features, and is more complicated. The message must be defined exactly as follows: message Foo { option message_set_wire_format = true; extensions 4 to max; } Note that the message cannot have any defined fields; MessageSets only have extensions. All extensions of your type must be singular messages; e.g. they cannot be int32s, enums, or repeated messages. Because this is an option, the above two restrictions are not enforced by the protocol compiler. Field number for the "no_standard_descriptor_accessor" field. Disables the generation of the standard "descriptor()" accessor, which can conflict with a field of the same name. This is meant to make migration from proto1 easier; new code should avoid fields named "descriptor". Field number for the "deprecated" field. Is this message deprecated? Depending on the target platform, this can emit Deprecated annotations for the message, or it will be completely ignored; in the very least, this is a formalization for deprecating messages. Field number for the "map_entry" field. Whether the message is an automatically generated map entry type for the maps field. For maps fields: map<KeyType, ValueType> map_field = 1; The parsed descriptor looks like: message MapFieldEntry { option map_entry = true; optional KeyType key = 1; optional ValueType value = 2; } repeated MapFieldEntry map_field = 1; Implementations may choose not to generate the map_entry=true message, but use a native map in the target language to hold the keys and values. The reflection APIs in such implementions still need to work as if the field is a repeated message field. NOTE: Do not set the option in .proto files. Always use the maps syntax instead. The option should only be implicitly set by the proto compiler parser. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Field number for the "ctype" field. The ctype option instructs the C++ code generator to use a different representation of the field than it normally would. See the specific options below. This option is not yet implemented in the open source release -- sorry, we'll try to include it in a future version! Field number for the "packed" field. The packed option can be enabled for repeated primitive fields to enable a more efficient representation on the wire. Rather than repeatedly writing the tag and type for each element, the entire array is encoded as a single length-delimited blob. In proto3, only explicit setting it to false will avoid using packed encoding. Field number for the "jstype" field. The jstype option determines the JavaScript type used for values of the field. The option is permitted only for 64 bit integral and fixed types (int64, uint64, sint64, fixed64, sfixed64). By default these types are represented as JavaScript strings. This avoids loss of precision that can happen when a large value is converted to a floating point JavaScript numbers. Specifying JS_NUMBER for the jstype causes the generated JavaScript code to use the JavaScript "number" type instead of strings. This option is an enum to permit additional types to be added, e.g. goog.math.Integer. Field number for the "lazy" field. Should this field be parsed lazily? Lazy applies only to message-type fields. It means that when the outer message is initially parsed, the inner message's contents will not be parsed but instead stored in encoded form. The inner message will actually be parsed when it is first accessed. This is only a hint. Implementations are free to choose whether to use eager or lazy parsing regardless of the value of this option. However, setting this option true suggests that the protocol author believes that using lazy parsing on this field is worth the additional bookkeeping overhead typically needed to implement it. This option does not affect the public interface of any generated code; all method signatures remain the same. Furthermore, thread-safety of the interface is not affected by this option; const methods remain safe to call from multiple threads concurrently, while non-const methods continue to require exclusive access. Note that implementations may choose not to check required fields within a lazy sub-message. That is, calling IsInitialized() on the outher message may return true even if the inner message has missing required fields. This is necessary because otherwise the inner message would have to be parsed in order to perform the check, defeating the purpose of lazy parsing. An implementation which chooses not to check required fields must be consistent about it. That is, for any particular sub-message, the implementation must either *always* check its required fields, or *never* check its required fields, regardless of whether or not the message has been parsed. Field number for the "deprecated" field. Is this field deprecated? Depending on the target platform, this can emit Deprecated annotations for accessors, or it will be completely ignored; in the very least, this is a formalization for deprecating fields. Field number for the "weak" field. For Google-internal migration only. Do not use. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Container for nested types declared in the FieldOptions message type. Default mode. Use the default type. Use JavaScript strings. Use JavaScript numbers. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Field number for the "allow_alias" field. Set this option to true to allow mapping different tag names to the same value. Field number for the "deprecated" field. Is this enum deprecated? Depending on the target platform, this can emit Deprecated annotations for the enum, or it will be completely ignored; in the very least, this is a formalization for deprecating enums. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Field number for the "deprecated" field. Is this enum value deprecated? Depending on the target platform, this can emit Deprecated annotations for the enum value, or it will be completely ignored; in the very least, this is a formalization for deprecating enum values. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Field number for the "deprecated" field. Is this service deprecated? Depending on the target platform, this can emit Deprecated annotations for the service, or it will be completely ignored; in the very least, this is a formalization for deprecating services. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. Field number for the "deprecated" field. Is this method deprecated? Depending on the target platform, this can emit Deprecated annotations for the method, or it will be completely ignored; in the very least, this is a formalization for deprecating methods. Field number for the "uninterpreted_option" field. The parser stores options it doesn't recognize here. See above. A message representing a option the parser does not recognize. This only appears in options protos created by the compiler::Parser class. DescriptorPool resolves these when building Descriptor objects. Therefore, options protos in descriptor objects (e.g. returned by Descriptor::options(), or produced by Descriptor::CopyTo()) will never have UninterpretedOptions in them. Field number for the "name" field. Field number for the "identifier_value" field. The value of the uninterpreted option, in whatever type the tokenizer identified it as during parsing. Exactly one of these should be set. Field number for the "positive_int_value" field. Field number for the "negative_int_value" field. Field number for the "double_value" field. Field number for the "string_value" field. Field number for the "aggregate_value" field. Container for nested types declared in the UninterpretedOption message type. The name of the uninterpreted option. Each string represents a segment in a dot-separated name. is_extension is true iff a segment represents an extension (denoted with parentheses in options specs in .proto files). E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents "foo.(bar.baz).qux". Field number for the "name_part" field. Field number for the "is_extension" field. Encapsulates information about the original source file from which a FileDescriptorProto was generated. Field number for the "location" field. A Location identifies a piece of source code in a .proto file which corresponds to a particular definition. This information is intended to be useful to IDEs, code indexers, documentation generators, and similar tools. For example, say we have a file like: message Foo { optional string foo = 1; } Let's look at just the field definition: optional string foo = 1; ^ ^^ ^^ ^ ^^^ a bc de f ghi We have the following locations: span path represents [a,i) [ 4, 0, 2, 0 ] The whole field definition. [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). [c,d) [ 4, 0, 2, 0, 5 ] The type (string). [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). [g,h) [ 4, 0, 2, 0, 3 ] The number (1). Notes: - A location may refer to a repeated field itself (i.e. not to any particular index within it). This is used whenever a set of elements are logically enclosed in a single code segment. For example, an entire extend block (possibly containing multiple extension definitions) will have an outer location whose path refers to the "extensions" repeated field without an index. - Multiple locations may have the same path. This happens when a single logical declaration is spread out across multiple places. The most obvious example is the "extend" block again -- there may be multiple extend blocks in the same scope, each of which will have the same path. - A location's span is not always a subset of its parent's span. For example, the "extendee" of an extension declaration appears at the beginning of the "extend" block and is shared by all extensions within the block. - Just because a location's span is a subset of some other location's span does not mean that it is a descendent. For example, a "group" defines both a type and a field in a single declaration. Thus, the locations corresponding to the type and field and their components will overlap. - Code which tries to interpret locations should probably be designed to ignore those that it doesn't understand, as more types of locations could be recorded in the future. Container for nested types declared in the SourceCodeInfo message type. Field number for the "path" field. Identifies which part of the FileDescriptorProto was defined at this location. Each element is a field number or an index. They form a path from the root FileDescriptorProto to the place where the definition. For example, this path: [ 4, 3, 2, 7, 1 ] refers to: file.message_type(3) // 4, 3 .field(7) // 2, 7 .name() // 1 This is because FileDescriptorProto.message_type has field number 4: repeated DescriptorProto message_type = 4; and DescriptorProto.field has field number 2: repeated FieldDescriptorProto field = 2; and FieldDescriptorProto.name has field number 1: optional string name = 1; Thus, the above path gives the location of a field name. If we removed the last element: [ 4, 3, 2, 7 ] this path refers to the whole field declaration (from the beginning of the label to the terminating semicolon). Field number for the "span" field. Always has exactly three or four elements: start line, start column, end line (optional, otherwise assumed same as start line), end column. These are packed into a single field for efficiency. Note that line and column numbers are zero-based -- typically you will want to add 1 to each before displaying to a user. Field number for the "leading_comments" field. If this SourceCodeInfo represents a complete declaration, these are any comments appearing before and after the declaration which appear to be attached to the declaration. A series of line comments appearing on consecutive lines, with no other tokens appearing on those lines, will be treated as a single comment. leading_detached_comments will keep paragraphs of comments that appear before (but not connected to) the current element. Each paragraph, separated by empty lines, will be one comment element in the repeated field. Only the comment content is provided; comment markers (e.g. //) are stripped out. For block comments, leading whitespace and an asterisk will be stripped from the beginning of each line other than the first. Newlines are included in the output. Examples: optional int32 foo = 1; // Comment attached to foo. // Comment attached to bar. optional int32 bar = 2; optional string baz = 3; // Comment attached to baz. // Another line attached to baz. // Comment attached to qux. // // Another line attached to qux. optional double qux = 4; // Detached comment for corge. This is not leading or trailing comments // to qux or corge because there are blank lines separating it from // both. // Detached comment for corge paragraph 2. optional string corge = 5; /* Block comment attached * to corge. Leading asterisks * will be removed. */ /* Block comment attached to * grault. */ optional int32 grault = 6; // ignored detached comments. Field number for the "trailing_comments" field. Field number for the "leading_detached_comments" field. Describes the relationship between generated code and its original source file. A GeneratedCodeInfo message is associated with only one generated source file, but may contain references to different source .proto files. Field number for the "annotation" field. An Annotation connects some span of text in generated code to an element of its generating .proto file. Container for nested types declared in the GeneratedCodeInfo message type. Field number for the "path" field. Identifies the element in the original source .proto file. This field is formatted the same as SourceCodeInfo.Location.path. Field number for the "source_file" field. Identifies the filesystem path to the original source .proto. Field number for the "begin" field. Identifies the starting offset in bytes in the generated code that relates to the identified object. Field number for the "end" field. Identifies the ending offset in bytes in the generated code that relates to the identified offset. The end offset should be one past the last relevant byte (so the length of the text = end - begin). Base class for nearly all descriptors, providing common functionality. The index of this descriptor within its parent descriptor. This returns the index of this descriptor within its parent, for this descriptor's type. (There can be duplicate values for different types, e.g. one enum type with index 0 and one message type with index 0.) Returns the name of the entity (field, message etc) being described. The fully qualified name of the descriptor's target. The file this descriptor was declared in. Contains lookup tables containing all the descriptors defined in a particular file. Finds a symbol of the given name within the pool. The type of symbol to look for Fully-qualified name to look up The symbol with the given name and type, or null if the symbol doesn't exist or has the wrong type Adds a package to the symbol tables. If a package by the same name already exists, that is fine, but if some other kind of symbol exists under the same name, an exception is thrown. If the package has multiple components, this also adds the parent package(s). Adds a symbol to the symbol table. The symbol already existed in the symbol table. Verifies that the descriptor's name is valid (i.e. it contains only letters, digits and underscores, and does not start with a digit). Returns the field with the given number in the given descriptor, or null if it can't be found. Adds a field to the fieldsByNumber table. A field with the same containing type and number already exists. Adds an enum value to the enumValuesByNumber table. If an enum value with the same type and number already exists, this method does nothing. (This is allowed; the first value defined with the number takes precedence.) Looks up a descriptor by name, relative to some other descriptor. The name may be fully-qualified (with a leading '.'), partially-qualified, or unqualified. C++-like name lookup semantics are used to search for the matching descriptor. This isn't heavily optimized, but it's only used during cross linking anyway. If it starts being used more widely, we should look at performance more carefully. Struct used to hold the keys for the fieldByNumber table. Internal class containing utility methods when working with descriptors. Equivalent to Func[TInput, int, TOutput] but usable in .NET 2.0. Only used to convert arrays. Converts the given array into a read-only list, applying the specified conversion to each input element. Thrown when building descriptors fails because the source DescriptorProtos are not valid. The full name of the descriptor where the error occurred. A human-readable description of the error. (The Message property is made up of the descriptor's name and this description.) Descriptor for an enum type in a .proto file. The brief name of the descriptor's target. The CLR type for this enum. For generated code, this will be a CLR enum type. If this is a nested type, get the outer descriptor, otherwise null. An unmodifiable list of defined value descriptors for this enum. Finds an enum value by number. If multiple enum values have the same number, this returns the first defined value with that number. If there is no value for the given number, this returns null. Finds an enum value by name. The unqualified name of the value (e.g. "FOO"). The value's descriptor, or null if not found. Descriptor for a single enum value within an enum in a .proto file. Returns the name of the enum value described by this object. Returns the number associated with this enum value. Returns the enum descriptor that this value is part of. Base class for field accessors. Descriptor for a field or extension within a message in a .proto file. Get the field's containing message type. Returns the oneof containing this field, or null if it is not part of a oneof. The effective JSON name for this field. This is usually the lower-camel-cased form of the field name, but can be overridden using the json_name option in the .proto file. The brief name of the descriptor's target. Returns the accessor for this field. While a describes the field, it does not provide any way of obtaining or changing the value of the field within a specific message; that is the responsibility of the accessor. The value returned by this property will be non-null for all regular fields. However, if a message containing a map field is introspected, the list of nested messages will include an auto-generated nested key/value pair message for the field. This is not represented in any generated type, and the value of the map field itself is represented by a dictionary in the reflection API. There are never instances of those "hidden" messages, so no accessor is provided and this property will return null. Maps a field type as included in the .proto file to a FieldType. Returns true if this field is a repeated field; false otherwise. Returns true if this field is a map field; false otherwise. Returns true if this field is a packed, repeated field; false otherwise. Returns the type of the field. Returns the field number declared in the proto file. Compares this descriptor with another one, ordering in "canonical" order which simply means ascending order by field number. must be a field of the same type, i.e. the of both fields must be the same. For enum fields, returns the field's type. For embedded message and group fields, returns the field's type. Look up and cross-link all field types etc. Enumeration of all the possible field types. The double field type. The float field type. The int64 field type. The uint64 field type. The int32 field type. The fixed64 field type. The fixed32 field type. The bool field type. The string field type. The field type used for groups (not supported in this implementation). The field type used for message fields. The bytes field type. The uint32 field type. The sfixed32 field type. The sfixed64 field type. The sint32 field type. The sint64 field type. The field type used for enum fields. Describes a .proto file, including everything defined within. IDescriptor is implemented such that the File property returns this descriptor, and the FullName is the same as the Name. Computes the full name of a descriptor within this file, with an optional parent message. Extracts public dependencies from direct dependencies. This is a static method despite its first parameter, as the value we're in the middle of constructing is only used for exceptions. The descriptor in its protocol message representation. The file name. The package as declared in the .proto file. This may or may not be equivalent to the .NET namespace of the generated classes. Unmodifiable list of top-level message types declared in this file. Unmodifiable list of top-level enum types declared in this file. Unmodifiable list of top-level services declared in this file. Unmodifiable list of this file's dependencies (imports). Unmodifiable list of this file's public dependencies (public imports). The original serialized binary form of this descriptor. Implementation of IDescriptor.FullName - just returns the same as Name. Implementation of IDescriptor.File - just returns this descriptor. Pool containing symbol descriptors. Finds a type (message, enum, service or extension) in the file by name. Does not find nested types. The unqualified type name to look for. The type of descriptor to look for The type's descriptor, or null if not found. Builds a FileDescriptor from its protocol buffer representation. The original serialized descriptor data. We have only limited proto2 support, so serializing FileDescriptorProto would not necessarily give us this. The protocol message form of the FileDescriptor. FileDescriptors corresponding to all of the file's dependencies, in the exact order listed in the .proto file. May be null, in which case it is treated as an empty array. Whether unknown dependencies are ignored (true) or cause an exception to be thrown (false). Details about generated code, for the purposes of reflection. If is not a valid descriptor. This can occur for a number of reasons, such as a field having an undefined type or because two messages were defined with the same name. Creates a descriptor for generated code. This method is only designed to be used by the results of generating code with protoc, which creates the appropriate dependencies etc. It has to be public because the generated code is "external", but should not be called directly by end users. Returns a that represents this instance. A that represents this instance. Returns the file descriptor for descriptor.proto. This is used for protos which take a direct dependency on descriptor.proto, typically for annotations. While descriptor.proto is a proto2 file, it is built into the Google.Protobuf runtime for reflection purposes. The messages are internal to the runtime as they would require proto2 semantics for full support, but the file descriptor is available via this property. The C# codegen in protoc automatically uses this property when it detects a dependency on descriptor.proto. The file descriptor for descriptor.proto. Extra information provided by generated code when initializing a message or file descriptor. These are constructed as required, and are not long-lived. Hand-written code should never need to use this type. Irrelevant for file descriptors; the CLR type for the message for message descriptors. Irrelevant for file descriptors; the parser for message descriptors. Irrelevant for file descriptors; the CLR property names (in message descriptor field order) for fields in the message for message descriptors. Irrelevant for file descriptors; the CLR property "base" names (in message descriptor oneof order) for oneofs in the message for message descriptors. It is expected that for a oneof name of "Foo", there will be a "FooCase" property and a "ClearFoo" method. The reflection information for types within this file/message descriptor. Elements may be null if there is no corresponding generated type, e.g. for map entry types. The CLR types for enums within this file/message descriptor. Creates a GeneratedClrTypeInfo for a message descriptor, with nested types, nested enums, the CLR type, property names and oneof names. Each array parameter may be null, to indicate a lack of values. The parameter order is designed to make it feasible to format the generated code readably. Creates a GeneratedClrTypeInfo for a file descriptor, with only types and enums. Interface implemented by all descriptor types. Returns the name of the entity (message, field etc) being described. Returns the fully-qualified name of the entity being described. Returns the descriptor for the .proto file that this entity is part of. Allows fields to be reflectively accessed. Returns the descriptor associated with this field. Clears the field in the specified message. (For repeated fields, this clears the list.) Fetches the field value. For repeated values, this will be an implementation. For map values, this will be an implementation. Mutator for single "simple" fields only. Repeated fields are mutated by fetching the value and manipulating it as a list. Map fields are mutated by fetching the value and manipulating it as a dictionary. The field is not a "simple" field. Accessor for map fields. Describes a message type. The brief name of the descriptor's target. The CLR type used to represent message instances from this descriptor. The value returned by this property will be non-null for all regular fields. However, if a message containing a map field is introspected, the list of nested messages will include an auto-generated nested key/value pair message for the field. This is not represented in any generated type, so this property will return null in such cases. For wrapper types ( and the like), the type returned here will be the generated message type, not the native type used by reflection for fields of those types. Code using reflection should call to determine whether a message descriptor represents a wrapper type, and handle the result appropriately. A parser for this message type. As is not generic, this cannot be statically typed to the relevant type, but it should produce objects of a type compatible with . The value returned by this property will be non-null for all regular fields. However, if a message containing a map field is introspected, the list of nested messages will include an auto-generated nested key/value pair message for the field. No message parser object is created for such messages, so this property will return null in such cases. For wrapper types ( and the like), the parser returned here will be the generated message type, not the native type used by reflection for fields of those types. Code using reflection should call to determine whether a message descriptor represents a wrapper type, and handle the result appropriately. Returns whether this message is one of the "well known types" which may have runtime/protoc support. Returns whether this message is one of the "wrapper types" used for fields which represent primitive values with the addition of presence. If this is a nested type, get the outer descriptor, otherwise null. A collection of fields, which can be retrieved by name or field number. An unmodifiable list of this message type's nested types. An unmodifiable list of this message type's enum types. An unmodifiable list of the "oneof" field collections in this message type. Finds a field by field name. The unqualified name of the field (e.g. "foo"). The field's descriptor, or null if not found. Finds a field by field number. The field number within this message type. The field's descriptor, or null if not found. Finds a nested descriptor by name. The is valid for fields, nested message types, oneofs and enums. The unqualified name of the descriptor, e.g. "Foo" The descriptor, or null if not found. Looks up and cross-links all fields and nested types. A collection to simplify retrieving the field accessor for a particular field. Returns the fields in the message as an immutable list, in the order in which they are declared in the source .proto file. Returns the fields in the message as an immutable list, in ascending field number order. Field numbers need not be contiguous, so there is no direct mapping from the index in the list to the field number; to retrieve a field by field number, it is better to use the indexer. Returns a read-only dictionary mapping the field names in this message as they're available in the JSON representation to the field descriptors. For example, a field foo_bar in the message would result two entries, one with a key fooBar and one with a key foo_bar, both referring to the same field. Retrieves the descriptor for the field with the given number. Number of the field to retrieve the descriptor for The accessor for the given field The message descriptor does not contain a field with the given number Retrieves the descriptor for the field with the given name. Name of the field to retrieve the descriptor for The descriptor for the given field The message descriptor does not contain a field with the given name Describes a single method in a service. The service this method belongs to. The method's input type. The method's input type. Indicates if client streams multiple requests. Indicates if server streams multiple responses. The brief name of the descriptor's target. Reflection access for a oneof, allowing clear and "get case" actions. Gets the descriptor for this oneof. The descriptor of the oneof. Clears the oneof in the specified message. Indicates which field in the oneof is set for specified message Describes a "oneof" field collection in a message type: a set of fields of which at most one can be set in any particular message. The brief name of the descriptor's target. Gets the message type containing this oneof. The message type containing this oneof. Gets the fields within this oneof, in declaration order. The fields within this oneof, in declaration order. Gets an accessor for reflective access to the values associated with the oneof in a particular message. The accessor used for reflective access. Specifies the original name (in the .proto file) of a named element, such as an enum value. The name of the element in the .proto file. Constructs a new attribute instance for the given name. The name of the element in the .proto file. Represents a package in the symbol table. We use PackageDescriptors just as placeholders so that someone cannot define, say, a message type that has the same name as an existing package. In order to run on iOS (no JIT) we had to use Invoke which results in a bit of a performance cost. The original description is as follows: The methods in this class are somewhat evil, and should not be tampered with lightly. Basically they allow the creation of relatively weakly typed delegates from MethodInfos which are more strongly typed. They do this by creating an appropriate strongly typed delegate from the MethodInfo, and then calling that within an anonymous method. Mind-bending stuff (at least to your humble narrator) but the resulting delegates are very fast compared with calling Invoke later on. Empty Type[] used when calling GetProperty to force property instead of indexer fetching. Creates a delegate which will cast the argument to the appropriate method target type, call the method on it, then convert the result to object. Creates a delegate which will cast the argument to the appropriate method target type, call the method on it, then convert the result to the specified type. Creates a delegate which will execute the given method after casting the first argument to the target type of the method, and the second argument to the first parameter type of the method. Creates a delegate which will execute the given method after casting the first argument to the target type of the method. Accessor for repeated fields. Describes a service type. The brief name of the descriptor's target. An unmodifiable list of methods in this service. Finds a method by name. The unqualified name of the method (e.g. "Foo"). The method's decsriptor, or null if not found. Accessor for single fields. An immutable registry of types which can be looked up by their full name. An empty type registry, containing no types. Attempts to find a message descriptor by its full name. The full name of the message, which is the dot-separated combination of package, containing messages and message name The message descriptor corresponding to or null if there is no such message descriptor. Creates a type registry from the specified set of file descriptors. This is a convenience overload for to allow calls such as TypeRegistry.FromFiles(descriptor1, descriptor2). The set of files to include in the registry. Must not contain null values. A type registry for the given files. Creates a type registry from the specified set of file descriptors. All message types within all the specified files are added to the registry, and the dependencies of the specified files are also added, recursively. The set of files to include in the registry. Must not contain null values. A type registry for the given files. Creates a type registry from the file descriptor parents of the specified set of message descriptors. This is a convenience overload for to allow calls such as TypeRegistry.FromFiles(descriptor1, descriptor2). The set of message descriptors to use to identify file descriptors to include in the registry. Must not contain null values. A type registry for the given files. Creates a type registry from the file descriptor parents of the specified set of message descriptors. The specified message descriptors are only used to identify their file descriptors; the returned registry contains all the types within the file descriptors which contain the specified message descriptors (and the dependencies of those files), not just the specified messages. The set of message descriptors to use to identify file descriptors to include in the registry. Must not contain null values. A type registry for the given files. Builder class which isn't exposed, but acts as a convenient alternative to passing round two dictionaries in recursive calls. Holder for reflection information generated from google/protobuf/any.proto File descriptor for google/protobuf/any.proto `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": <string>, "lastName": <string> } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } Field number for the "type_url" field. A URL/resource name whose content describes the type of the serialized protocol buffer message. For URLs which use the scheme `http`, `https`, or no scheme, the following restrictions and interpretations apply: * If no scheme is provided, `https` is assumed. * The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. Field number for the "value" field. Must be a valid serialized protocol buffer of the above specified type. Retrieves the type name for a type URL. This is always just the last part of the URL, after the trailing slash. No validation of anything before the trailing slash is performed. If the type URL does not include a slash, an empty string is returned rather than an exception being thrown; this won't match any types, and the calling code is probably in a better position to give a meaningful error. There is no handling of fragments or queries at the moment. The URL to extract the type name from The type name Unpacks the content of this Any message into the target message type, which must match the type URL within this Any message. The type of message to unpack the content into. The unpacked message. The target message type doesn't match the type URL in this message Packs the specified message into an Any message using a type URL prefix of "type.googleapis.com". The message to pack. An Any message with the content and type URL of . Packs the specified message into an Any message using the specified type URL prefix. The message to pack. The prefix for the type URL. An Any message with the content and type URL of . Holder for reflection information generated from google/protobuf/api.proto File descriptor for google/protobuf/api.proto Api is a light-weight descriptor for a protocol buffer service. Field number for the "name" field. The fully qualified name of this api, including package name followed by the api's simple name. Field number for the "methods" field. The methods of this api, in unspecified order. Field number for the "options" field. Any metadata attached to the API. Field number for the "version" field. A version string for this api. If specified, must have the form `major-version.minor-version`, as in `1.10`. If the minor version is omitted, it defaults to zero. If the entire version field is empty, the major version is derived from the package name, as outlined below. If the field is not empty, the version in the package name will be verified to be consistent with what is provided here. The versioning schema uses [semantic versioning](http://semver.org) where the major version number indicates a breaking change and the minor version an additive, non-breaking change. Both version numbers are signals to users what to expect from different versions, and should be carefully chosen based on the product plan. The major version is also reflected in the package name of the API, which must end in `v<major-version>`, as in `google.feature.v1`. For major versions 0 and 1, the suffix can be omitted. Zero major versions must only be used for experimental, none-GA apis. Field number for the "source_context" field. Source context for the protocol buffer service represented by this message. Field number for the "mixins" field. Included APIs. See [Mixin][]. Field number for the "syntax" field. The source syntax of the service. Method represents a method of an api. Field number for the "name" field. The simple name of this method. Field number for the "request_type_url" field. A URL of the input message type. Field number for the "request_streaming" field. If true, the request is streamed. Field number for the "response_type_url" field. The URL of the output message type. Field number for the "response_streaming" field. If true, the response is streamed. Field number for the "options" field. Any metadata attached to the method. Field number for the "syntax" field. The source syntax of this method. Declares an API to be included in this API. The including API must redeclare all the methods from the included API, but documentation and options are inherited as follows: - If after comment and whitespace stripping, the documentation string of the redeclared method is empty, it will be inherited from the original method. - Each annotation belonging to the service config (http, visibility) which is not set in the redeclared method will be inherited. - If an http annotation is inherited, the path pattern will be modified as follows. Any version prefix will be replaced by the version of the including API plus the [root][] path if specified. Example of a simple mixin: package google.acl.v1; service AccessControl { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v1/{resource=**}:getAcl"; } } package google.storage.v2; service Storage { rpc GetAcl(GetAclRequest) returns (Acl); // Get a data record. rpc GetData(GetDataRequest) returns (Data) { option (google.api.http).get = "/v2/{resource=**}"; } } Example of a mixin configuration: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl The mixin construct implies that all methods in `AccessControl` are also declared with same name and request/response types in `Storage`. A documentation generator or annotation processor will see the effective `Storage.GetAcl` method after inherting documentation and annotations as follows: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/{resource=**}:getAcl"; } ... } Note how the version in the path pattern changed from `v1` to `v2`. If the `root` field in the mixin is specified, it should be a relative path under which inherited HTTP paths are placed. Example: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl root: acls This implies the following inherited HTTP annotation: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; } ... } Field number for the "name" field. The fully qualified name of the API which is included. Field number for the "root" field. If non-empty specifies a path under which inherited HTTP paths are rooted. Holder for reflection information generated from google/protobuf/duration.proto File descriptor for google/protobuf/duration.proto A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. Example 1: Compute Duration from two Timestamps in pseudo code. Timestamp start = ...; Timestamp end = ...; Duration duration = ...; duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; if (duration.seconds < 0 && duration.nanos > 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. Timestamp start = ...; Duration duration = ...; Timestamp end = ...; end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; if (end.nanos < 0) { end.seconds -= 1; end.nanos += 1000000000; } else if (end.nanos >= 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } Field number for the "seconds" field. Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Field number for the "nanos" field. Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive. The number of nanoseconds in a second. The number of nanoseconds in a BCL tick (as used by and ). The maximum permitted number of seconds. The minimum permitted number of seconds. Converts this to a . If the duration is not a precise number of ticks, it is truncated towards 0. The value of this duration, as a TimeSpan. This value isn't a valid normalized duration, as described in the documentation. Converts the given to a . The TimeSpan to convert. The value of the given TimeSpan, as a Duration. Returns the result of negating the duration. For example, the negation of 5 minutes is -5 minutes. The duration to negate. Must not be null. The negated value of this duration. Adds the two specified values together. The first value to add. Must not be null. The second value to add. Must not be null. Subtracts one from another. The duration to subtract from. Must not be null. The duration to subtract. Must not be null. The difference between the two specified durations. Creates a duration with the normalized values from the given number of seconds and nanoseconds, conforming with the description in the proto file. Converts a duration specified in seconds/nanoseconds to a string. If the value is a normalized duration in the range described in duration.proto, is ignored. Otherwise, if the parameter is true, a JSON object with a warning is returned; if it is false, an is thrown. Seconds portion of the duration. Nanoseconds portion of the duration. Determines the handling of non-normalized values The represented duration is invalid, and is false. Returns a string representation of this for diagnostic purposes. Normally the returned value will be a JSON string value (including leading and trailing quotes) but when the value is non-normalized or out of range, a JSON object representation will be returned instead, including a warning. This is to avoid exceptions being thrown when trying to diagnose problems - the regular JSON formatter will still throw an exception for non-normalized values. A string representation of this value. Appends a number of nanoseconds to a StringBuilder. Either 0 digits are added (in which case no "." is appended), or 3 6 or 9 digits. This is internal for use in Timestamp as well as Duration. Holder for reflection information generated from google/protobuf/empty.proto File descriptor for google/protobuf/empty.proto A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`. Holder for reflection information generated from google/protobuf/field_mask.proto File descriptor for google/protobuf/field_mask.proto `FieldMask` represents a set of symbolic field paths, for example: paths: "f.a" paths: "f.b.d" Here `f` represents a field in some root message, `a` and `b` fields in the message found in `f`, and `d` a field found in the message in `f.b`. Field masks are used to specify a subset of fields that should be returned by a get operation or modified by an update operation. Field masks also have a custom JSON encoding (see below). # Field Masks in Projections When used in the context of a projection, a response message or sub-message is filtered by the API to only contain those fields as specified in the mask. For example, if the mask in the previous example is applied to a response message as follows: f { a : 22 b { d : 1 x : 2 } y : 13 } z: 8 The result will not contain specific values for fields x,y and z (their value will be set to the default, and omitted in proto text output): f { a : 22 b { d : 1 } } A repeated field is not allowed except at the last position of a field mask. If a FieldMask object is not present in a get operation, the operation applies to all fields (as if a FieldMask of all fields had been specified). Note that a field mask does not necessarily apply to the top-level response message. In case of a REST get operation, the field mask applies directly to the response, but in case of a REST list operation, the mask instead applies to each individual message in the returned resource list. In case of a REST custom method, other definitions may be used. Where the mask applies will be clearly documented together with its declaration in the API. In any case, the effect on the returned resource/resources is required behavior for APIs. # Field Masks in Update Operations A field mask in update operations specifies which fields of the targeted resource are going to be updated. The API is required to only change the values of the fields as specified in the mask and leave the others untouched. If a resource is passed in to describe the updated values, the API ignores the values of all fields not covered by the mask. If a repeated field is specified for an update operation, the existing repeated values in the target resource will be overwritten by the new values. Note that a repeated field is only allowed in the last position of a field mask. If a sub-message is specified in the last position of the field mask for an update operation, then the existing sub-message in the target resource is overwritten. Given the target message: f { b { d : 1 x : 2 } c : 1 } And an update message: f { b { d : 10 } } then if the field mask is: paths: "f.b" then the result will be: f { b { d : 10 } c : 1 } However, if the update mask was: paths: "f.b.d" then the result would be: f { b { d : 10 x : 2 } c : 1 } In order to reset a field's value to the default, the field must be in the mask and set to the default value in the provided resource. Hence, in order to reset all fields of a resource, provide a default instance of the resource and set all fields in the mask, or do not provide a mask as described below. If a field mask is not present on update, the operation applies to all fields (as if a field mask of all fields has been specified). Note that in the presence of schema evolution, this may mean that fields the client does not know and has therefore not filled into the request will be reset to their default. If this is unwanted behavior, a specific service may require a client to always specify a field mask, producing an error if not. As with get operations, the location of the resource which describes the updated values in the request message depends on the operation kind. In any case, the effect of the field mask is required to be honored by the API. ## Considerations for HTTP REST The HTTP kind of an update operation which uses a field mask must be set to PATCH instead of PUT in order to satisfy HTTP semantics (PUT must only be used for full updates). # JSON Encoding of Field Masks In JSON, a field mask is encoded as a single string where paths are separated by a comma. Fields name in each path are converted to/from lower-camel naming conventions. As an example, consider the following message declarations: message Profile { User user = 1; Photo photo = 2; } message User { string display_name = 1; string address = 2; } In proto a field mask for `Profile` may look as such: mask { paths: "user.display_name" paths: "photo" } In JSON, the same mask is represented as below: { mask: "user.displayName,photo" } # Field Masks and Oneof Fields Field masks treat fields in oneofs just as regular fields. Consider the following message: message SampleMessage { oneof test_oneof { string name = 4; SubMessage sub_message = 9; } } The field mask can be: mask { paths: "name" } Or: mask { paths: "sub_message" } Note that oneof type names ("test_oneof" in this case) cannot be used in paths. Field number for the "paths" field. The set of field mask paths. Converts a timestamp specified in seconds/nanoseconds to a string. If the value is a normalized duration in the range described in field_mask.proto, is ignored. Otherwise, if the parameter is true, a JSON object with a warning is returned; if it is false, an is thrown. Paths in the field mask Determines the handling of non-normalized values The represented duration is invalid, and is false. Camel-case converter with added strictness for field mask formatting. The field mask is invalid for JSON representation Returns a string representation of this for diagnostic purposes. Normally the returned value will be a JSON string value (including leading and trailing quotes) but when the value is non-normalized or out of range, a JSON object representation will be returned instead, including a warning. This is to avoid exceptions being thrown when trying to diagnose problems - the regular JSON formatter will still throw an exception for non-normalized values. A string representation of this value. Holder for reflection information generated from google/protobuf/source_context.proto File descriptor for google/protobuf/source_context.proto `SourceContext` represents information about the source of a protobuf element, like the file in which it is defined. Field number for the "file_name" field. The path-qualified name of the .proto file that contained the associated protobuf element. For example: `"google/protobuf/source_context.proto"`. Holder for reflection information generated from google/protobuf/struct.proto File descriptor for google/protobuf/struct.proto `NullValue` is a singleton enumeration to represent the null value for the `Value` type union. The JSON representation for `NullValue` is JSON `null`. Null value. `Struct` represents a structured data value, consisting of fields which map to dynamically typed values. In some languages, `Struct` might be supported by a native representation. For example, in scripting languages like JS a struct is represented as an object. The details of that representation are described together with the proto support for the language. The JSON representation for `Struct` is JSON object. Field number for the "fields" field. Unordered map of dynamically typed values. `Value` represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of that variants, absence of any variant indicates an error. The JSON representation for `Value` is JSON value. Field number for the "null_value" field. Represents a null value. Field number for the "number_value" field. Represents a double value. Field number for the "string_value" field. Represents a string value. Field number for the "bool_value" field. Represents a boolean value. Field number for the "struct_value" field. Represents a structured value. Field number for the "list_value" field. Represents a repeated `Value`. Enum of possible cases for the "kind" oneof. Convenience method to create a Value message with a string value. Value to set for the StringValue property. A newly-created Value message with the given value. Convenience method to create a Value message with a number value. Value to set for the NumberValue property. A newly-created Value message with the given value. Convenience method to create a Value message with a Boolean value. Value to set for the BoolValue property. A newly-created Value message with the given value. Convenience method to create a Value message with a null initial value. A newly-created Value message a null initial value. Convenience method to create a Value message with an initial list of values. The values provided are not cloned; the references are copied directly. A newly-created Value message an initial list value. Convenience method to create a Value message with an initial struct value The value provided is not cloned; the reference is copied directly. A newly-created Value message an initial struct value. `ListValue` is a wrapper around a repeated field of values. The JSON representation for `ListValue` is JSON array. Field number for the "values" field. Repeated field of dynamically typed values. Extension methods on BCL time-related types, converting to protobuf types. Converts the given to a . The date and time to convert to a timestamp. The value has a other than Utc. The converted timestamp. Converts the given to a The offset is taken into consideration when converting the value (so the same instant in time is represented) but is not a separate part of the resulting value. In other words, there is no roundtrip operation to retrieve the original DateTimeOffset. The date and time (with UTC offset) to convert to a timestamp. The converted timestamp. Converts the given to a . The time span to convert. The converted duration. Holder for reflection information generated from google/protobuf/timestamp.proto File descriptor for google/protobuf/timestamp.proto A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from current time in Python. now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9) timestamp = Timestamp(seconds=seconds, nanos=nanos) Field number for the "seconds" field. Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive. Field number for the "nanos" field. Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive. Returns the difference between one and another, as a . The timestamp to subtract from. Must not be null. The timestamp to subtract. Must not be null. The difference between the two specified timestamps. Adds a to a , to obtain another Timestamp. The timestamp to add the duration to. Must not be null. The duration to add. Must not be null. The result of adding the duration to the timestamp. Subtracts a from a , to obtain another Timestamp. The timestamp to subtract the duration from. Must not be null. The duration to subtract. The result of subtracting the duration from the timestamp. Converts this timestamp into a . The resulting DateTime will always have a Kind of Utc. If the timestamp is not a precise number of ticks, it will be truncated towards the start of time. For example, a timestamp with a value of 99 will result in a value precisely on a second. This timestamp as a DateTime. The timestamp contains invalid values; either it is incorrectly normalized or is outside the valid range. Converts this timestamp into a . The resulting DateTimeOffset will always have an Offset of zero. If the timestamp is not a precise number of ticks, it will be truncated towards the start of time. For example, a timestamp with a value of 99 will result in a value precisely on a second. This timestamp as a DateTimeOffset. The timestamp contains invalid values; either it is incorrectly normalized or is outside the valid range. Converts the specified to a . The Kind of is not DateTimeKind.Utc. The converted timestamp. Converts the given to a The offset is taken into consideration when converting the value (so the same instant in time is represented) but is not a separate part of the resulting value. In other words, there is no roundtrip operation to retrieve the original DateTimeOffset. The date and time (with UTC offset) to convert to a timestamp. The converted timestamp. Converts a timestamp specified in seconds/nanoseconds to a string. If the value is a normalized duration in the range described in timestamp.proto, is ignored. Otherwise, if the parameter is true, a JSON object with a warning is returned; if it is false, an is thrown. Seconds portion of the duration. Nanoseconds portion of the duration. Determines the handling of non-normalized values The represented duration is invalid, and is false. Returns a string representation of this for diagnostic purposes. Normally the returned value will be a JSON string value (including leading and trailing quotes) but when the value is non-normalized or out of range, a JSON object representation will be returned instead, including a warning. This is to avoid exceptions being thrown when trying to diagnose problems - the regular JSON formatter will still throw an exception for non-normalized values. A string representation of this value. Holder for reflection information generated from google/protobuf/type.proto File descriptor for google/protobuf/type.proto The syntax in which a protocol buffer element is defined. Syntax `proto2`. Syntax `proto3`. A protocol buffer message type. Field number for the "name" field. The fully qualified message name. Field number for the "fields" field. The list of fields. Field number for the "oneofs" field. The list of types appearing in `oneof` definitions in this type. Field number for the "options" field. The protocol buffer options. Field number for the "source_context" field. The source context. Field number for the "syntax" field. The source syntax. A single field of a message type. Field number for the "kind" field. The field type. Field number for the "cardinality" field. The field cardinality. Field number for the "number" field. The field number. Field number for the "name" field. The field name. Field number for the "type_url" field. The field type URL, without the scheme, for message or enumeration types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. Field number for the "oneof_index" field. The index of the field type in `Type.oneofs`, for message or enumeration types. The first type has index 1; zero means the type is not in the list. Field number for the "packed" field. Whether to use alternative packed wire representation. Field number for the "options" field. The protocol buffer options. Field number for the "json_name" field. The field JSON name. Field number for the "default_value" field. The string value of the default value of this field. Proto2 syntax only. Container for nested types declared in the Field message type. Basic field types. Field type unknown. Field type double. Field type float. Field type int64. Field type uint64. Field type int32. Field type fixed64. Field type fixed32. Field type bool. Field type string. Field type group. Proto2 syntax only, and deprecated. Field type message. Field type bytes. Field type uint32. Field type enum. Field type sfixed32. Field type sfixed64. Field type sint32. Field type sint64. Whether a field is optional, required, or repeated. For fields with unknown cardinality. For optional fields. For required fields. Proto2 syntax only. For repeated fields. Enum type definition. Field number for the "name" field. Enum type name. Field number for the "enumvalue" field. Enum value definitions. Field number for the "options" field. Protocol buffer options. Field number for the "source_context" field. The source context. Field number for the "syntax" field. The source syntax. Enum value definition. Field number for the "name" field. Enum value name. Field number for the "number" field. Enum value number. Field number for the "options" field. Protocol buffer options. A protocol buffer option, which can be attached to a message, field, enumeration, etc. Field number for the "name" field. The option's name. For example, `"java_package"`. Field number for the "value" field. The option's value. For example, `"com.google.protobuf"`. Holder for reflection information generated from google/protobuf/wrappers.proto File descriptor for google/protobuf/wrappers.proto Field number for the single "value" field in all wrapper types. Wrapper message for `double`. The JSON representation for `DoubleValue` is JSON number. Field number for the "value" field. The double value. Wrapper message for `float`. The JSON representation for `FloatValue` is JSON number. Field number for the "value" field. The float value. Wrapper message for `int64`. The JSON representation for `Int64Value` is JSON string. Field number for the "value" field. The int64 value. Wrapper message for `uint64`. The JSON representation for `UInt64Value` is JSON string. Field number for the "value" field. The uint64 value. Wrapper message for `int32`. The JSON representation for `Int32Value` is JSON number. Field number for the "value" field. The int32 value. Wrapper message for `uint32`. The JSON representation for `UInt32Value` is JSON number. Field number for the "value" field. The uint32 value. Wrapper message for `bool`. The JSON representation for `BoolValue` is JSON `true` and `false`. Field number for the "value" field. The bool value. Wrapper message for `string`. The JSON representation for `StringValue` is JSON string. Field number for the "value" field. The string value. Wrapper message for `bytes`. The JSON representation for `BytesValue` is JSON string. Field number for the "value" field. The bytes value. This class is used internally by the Protocol Buffer Library and generated message implementations. It is public only for the sake of those generated messages. Others should not use this class directly. This class contains constants and helper functions useful for dealing with the Protocol Buffer wire format. Wire types within protobuf encoding. Variable-length integer. A fixed-length 64-bit value. A length-delimited value, i.e. a length followed by that many bytes of data. A "start group" value - not supported by this implementation. An "end group" value - not supported by this implementation. A fixed-length 32-bit value. Given a tag value, determines the wire type (lower 3 bits). Given a tag value, determines the field number (the upper 29 bits). Makes a tag value given a field number and wire type.