From ca9d1a053a8590caa1a1f81491b0381f052fa734 Mon Sep 17 00:00:00 2001 From: Feng Xiao Date: Mon, 20 Apr 2015 11:30:31 -0700 Subject: Include all well-known type protos. Change-Id: I122f1cee71a8a739ea603e52582cb0fa9698f0ed --- src/google/protobuf/any.proto | 12 +- src/google/protobuf/api.proto | 104 ++++++++++++++++ src/google/protobuf/duration.proto | 10 +- src/google/protobuf/empty.proto | 49 ++++++++ src/google/protobuf/source_context.proto | 45 +++++++ src/google/protobuf/struct.proto | 17 ++- src/google/protobuf/timestamp.proto | 13 +- src/google/protobuf/type.proto | 196 +++++++++++++++++++++++++++++++ 8 files changed, 425 insertions(+), 21 deletions(-) create mode 100644 src/google/protobuf/api.proto create mode 100644 src/google/protobuf/empty.proto create mode 100644 src/google/protobuf/source_context.proto create mode 100644 src/google/protobuf/type.proto (limited to 'src') diff --git a/src/google/protobuf/any.proto b/src/google/protobuf/any.proto index bf2aa0a9..3aba15b3 100644 --- a/src/google/protobuf/any.proto +++ b/src/google/protobuf/any.proto @@ -40,7 +40,8 @@ option java_package = "com.google.protobuf"; // `Any` contains an arbitrary serialized message along with a URL // that describes the type of the serialized message. // -// +// The proto runtimes and/or compiler will eventually +// provide utilities to pack/unpack Any values (projected Q1/15). // // # JSON // The JSON representation of an `Any` value uses the regular @@ -76,21 +77,24 @@ message Any { // For URLs which use the schema `http`, `https`, or no schema, the // following restrictions and interpretations apply: // - // * If no schema is provided, https is assumed. + // * If no schema 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`). // * An HTTP GET on the URL must yield a [google.protobuf.Type][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 need to be preserved + // lookup. Therefore, binary compatibility needs to be preserved // on changes to types. (Use versioned type names to manage // breaking changes.) // // Schemas other than `http`, `https` (or the empty schema) might be // used with implementation specific semantics. // - // + // Types originating from the `google.*` package + // namespace should use `type.googleapis.com/full.type.name` (without + // schema and path). A type service will eventually become available which + // serves those URLs (projected Q2/15). string type_url = 1; // Must be valid serialized data of the above specified type. diff --git a/src/google/protobuf/api.proto b/src/google/protobuf/api.proto new file mode 100644 index 00000000..00857f55 --- /dev/null +++ b/src/google/protobuf/api.proto @@ -0,0 +1,104 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/source_context.proto"; +import "google/protobuf/type.proto"; + +option java_multiple_files = true; +option java_outer_classname = "ApiProto"; +option java_package = "com.google.protobuf"; + + +// Api is a light-weight descriptor for a protocol buffer service. +message Api { + // The fully qualified name of this api, including package name + // followed by the api's simple name. + string name = 1; + + // The methods of this api, in unspecified order. + repeated Method methods = 2; + + // Any metadata attached to the API. + repeated Option options = 3; + + // 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`, 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. + // + // See also: [design doc](http://go/api-versioning). + // + // + string version = 4; + + // Source context for the protocol buffer service represented by this + // message. + SourceContext source_context = 5; +} + +// Method represents a method of an api. +message Method { + // The simple name of this method. + string name = 1; + + // A URL of the input message type. + string request_type_url = 2; + + // If true, the request is streamed. + bool request_streaming = 3; + + // The URL of the output message type. + string response_type_url = 4; + + // If true, the response is streamed. + bool response_streaming = 5; + + // Any metadata attached to the method. + repeated Option options = 6; +} diff --git a/src/google/protobuf/duration.proto b/src/google/protobuf/duration.proto index 868c732f..c6dd4adc 100644 --- a/src/google/protobuf/duration.proto +++ b/src/google/protobuf/duration.proto @@ -44,7 +44,7 @@ option java_package = "com.google.protobuf"; // 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. +// Example 1: Compute Duration from two Timestamps in pseudo code. // // Timestamp start = ...; // Timestamp end = ...; @@ -61,7 +61,7 @@ option java_package = "com.google.protobuf"; // duration.nanos += 1000000000; // } // -// Example 2: compute Timestamp from Timestamp + Duration in pseudo code. +// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. // // Timestamp start = ...; // Duration duration = ...; @@ -85,9 +85,9 @@ message Duration { // 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 + // `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. int32 nanos = 2; } diff --git a/src/google/protobuf/empty.proto b/src/google/protobuf/empty.proto new file mode 100644 index 00000000..46087d59 --- /dev/null +++ b/src/google/protobuf/empty.proto @@ -0,0 +1,49 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +syntax = "proto3"; + +package google.protobuf; + +option java_multiple_files = true; +option java_outer_classname = "EmptyProto"; +option java_package = "com.google.protobuf"; + + +// 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); +// } +// +message Empty { + +} diff --git a/src/google/protobuf/source_context.proto b/src/google/protobuf/source_context.proto new file mode 100644 index 00000000..a3874d6a --- /dev/null +++ b/src/google/protobuf/source_context.proto @@ -0,0 +1,45 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +syntax = "proto3"; + +package google.protobuf; + +option java_multiple_files = true; +option java_outer_classname = "SourceContextProto"; +option java_package = "com.google.protobuf"; + + +// `SourceContext` represents information about the source of a +// protobuf element, like the file in which it is defined. +message SourceContext { + // The path-qualified name of the .proto file that contained the associated + // protobuf element. For example: `"google/protobuf/source.proto"`. + string file_name = 1; +} diff --git a/src/google/protobuf/struct.proto b/src/google/protobuf/struct.proto index 9f27eb43..3a90ff37 100644 --- a/src/google/protobuf/struct.proto +++ b/src/google/protobuf/struct.proto @@ -56,28 +56,33 @@ message Value { oneof kind { // Represents a null value. NullValue null_value = 1; + // Represents a double value. double number_value = 2; + // Represents a string value. string string_value = 3; + // Represents a boolean value. bool bool_value = 4; + // Represents a structured value. Struct struct_value = 5; + // Represents a repeated `Value`. ListValue list_value = 6; } } +// `ListValue` is a wrapper around a repeated field of values. +message ListValue { + // Repeated field of dynamically typed values. + repeated Value values = 1; +} + // `NullValue` is a singleton enumeration to represent the null // value for the `Value` type union. enum NullValue { // Null value. NULL_VALUE = 0; } - -// `ListValue` is a wrapper around a repeated field of values. -message ListValue { - // Repeated field of dynamically typed values. - repeated Value values = 1; -} diff --git a/src/google/protobuf/timestamp.proto b/src/google/protobuf/timestamp.proto index ac8e009c..89956229 100644 --- a/src/google/protobuf/timestamp.proto +++ b/src/google/protobuf/timestamp.proto @@ -46,15 +46,16 @@ option java_package = "com.google.protobuf"; // 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.) +// 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()`. +// 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()`. +// Example 2: Compute Timestamp from POSIX `gettimeofday()`. // // struct timeval tv; // gettimeofday(&tv, NULL); @@ -63,7 +64,7 @@ option java_package = "com.google.protobuf"; // timestamp.set_seconds(tv.tv_sec); // timestamp.set_nanos(tv.tv_usec * 1000); // -// Example 3: compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. +// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. // // FILETIME ft; // GetSystemTimeAsFileTime(&ft); @@ -75,14 +76,14 @@ option java_package = "com.google.protobuf"; // timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); // timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); // -// Example 4: compute Timestamp from Java `System.currentTimeMillis()`. +// 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 Python `datetime.datetime`. +// Example 5: Compute Timestamp from Python `datetime.datetime`. // // now = datetime.datetime.utcnow() // seconds = int(time.mktime(now.timetuple())) diff --git a/src/google/protobuf/type.proto b/src/google/protobuf/type.proto new file mode 100644 index 00000000..04165c81 --- /dev/null +++ b/src/google/protobuf/type.proto @@ -0,0 +1,196 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/any.proto"; +import "google/protobuf/source_context.proto"; + +option java_multiple_files = true; +option java_outer_classname = "TypeProto"; +option java_package = "com.google.protobuf"; + + +// A light-weight descriptor for a proto message type. +message Type { + // The fully qualified message name. + string name = 1; + + // The list of fields. + repeated Field fields = 2; + + // The list of oneof definitions. + // The list of oneofs declared in this Type + repeated string oneofs = 3; + + // The proto options. + repeated Option options = 4; + + // The source context. + SourceContext source_context = 5; +} + +// Field represents a single field of a message type. +message Field { + // Kind represents a basic field type. + enum Kind { + // Field type unknown. + TYPE_UNKNOWN = 0; + + // Field type double. + TYPE_DOUBLE = 1; + + // Field type float. + TYPE_FLOAT = 2; + + // Field type int64. + TYPE_INT64 = 3; + + // Field type uint64. + TYPE_UINT64 = 4; + + // Field type int32. + TYPE_INT32 = 5; + + // Field type fixed64. + TYPE_FIXED64 = 6; + + // Field type fixed32. + TYPE_FIXED32 = 7; + + // Field type bool. + TYPE_BOOL = 8; + + // Field type string. + TYPE_STRING = 9; + + // Field type message. + TYPE_MESSAGE = 11; + + // Field type bytes. + TYPE_BYTES = 12; + + // Field type uint32. + TYPE_UINT32 = 13; + + // Field type enum. + TYPE_ENUM = 14; + + // Field type sfixed32. + TYPE_SFIXED32 = 15; + + // Field type sfixed64. + TYPE_SFIXED64 = 16; + + // Field type sint32. + TYPE_SINT32 = 17; + + // Field type sint64. + TYPE_SINT64 = 18; + } + + // Cardinality represents whether a field is optional, required, or + // repeated. + enum Cardinality { + // The field cardinality is unknown. Typically an error condition. + CARDINALITY_UNKNOWN = 0; + + // For optional fields. + CARDINALITY_OPTIONAL = 1; + + // For required fields. Not used for proto3. + CARDINALITY_REQUIRED = 2; + + // For repeated fields. + CARDINALITY_REPEATED = 3; + } + + // The field kind. + Kind kind = 1; + + // The field cardinality, i.e. optional/required/repeated. + Cardinality cardinality = 2; + + // The proto field number. + int32 number = 3; + + // The field name. + string name = 4; + + // The type URL (without the scheme) when the type is MESSAGE or ENUM, + // such as `type.googleapis.com/google.protobuf.Empty`. + string type_url = 6; + + // Index in Type.oneofs. Starts at 1. Zero means no oneof mapping. + int32 oneof_index = 7; + + // Whether to use alternative packed wire representation. + bool packed = 8; + + // The proto options. + repeated Option options = 9; +} + +// Enum type definition. +message Enum { + // Enum type name. + string name = 1; + + // Enum value definitions. + repeated EnumValue enumvalue = 2; + + // Proto options for the enum type. + repeated Option options = 3; + + // The source context. + SourceContext source_context = 4; +} + +// Enum value definition. +message EnumValue { + // Enum value name. + string name = 1; + + // Enum value number. + int32 number = 2; + + // Proto options for the enum value. + repeated Option options = 3; +} + +// Proto option attached to messages/fields/enums etc. +message Option { + // Proto option name. + string name = 1; + + // Proto option value. + Any value = 2; +} -- cgit v1.2.3