proto-lens-protobuf-types 0.5.0.0 → 0.7.2.3
raw patch · 16 files changed
Files
- Changelog.md +35/−0
- proto-lens-protobuf-types.cabal +60/−26
- proto-src/google/protobuf/any.proto +15/−7
- proto-src/google/protobuf/api.proto +207/−0
- proto-src/google/protobuf/compiler/plugin.proto +180/−0
- proto-src/google/protobuf/descriptor.proto +1296/−0
- proto-src/google/protobuf/duration.proto +3/−5
- proto-src/google/protobuf/empty.proto +2/−3
- proto-src/google/protobuf/field_mask.proto +245/−0
- proto-src/google/protobuf/source_context.proto +48/−0
- proto-src/google/protobuf/struct.proto +95/−0
- proto-src/google/protobuf/timestamp.proto +30/−21
- proto-src/google/protobuf/type.proto +193/−0
- proto-src/google/protobuf/wrappers.proto +8/−3
- src/Data/ProtoLens/Any.hs +11/−10
- src/Data/ProtoLens/Descriptor.hs +43/−0
Changelog.md view
@@ -1,5 +1,40 @@ # Changelog for `proto-lens-protobuf-types` +## v0.7.2.3+- Support GHC 9.12.+- Support GHC 9.14.+- Fix `Data.ProtoLens.Any` to not import `IsLabels` instance, allowing+ use of other `IsLabels` instances (e.g. from `generic-lens`) alongside+ `proto-lens-protobuf-types`.++## v0.7.2.2+- Bump upper bounds for ghc-9.10.++## v0.7.2.0+- Add support for additional well known types++## v0.7.1.2+- Add protobuf struct types (#438)++## v0.7.1.1+- Relax upper bounds for ghc-9.2++## v0.7.1.0+- Support GHC 9.0.+- Add ServiceDescriptor to generated services (#409)++## v0.7.0.0+- Add the module `Data.ProtoLens.Descriptor`. It exposes `messageDescriptor`,+ which makes it easier to get the descriptor proto for a given message type.+- Bump upper bound to allow base-4.14.++## v0.6.0.0+- Bump lower bounds to base-4.10 (ghc-8.2).+- Support dependencies on base-4.13 (ghc-8.8) and lens-family-2.0.+- Add new bindings `Proto.Google.Protobuf.Descriptor` and+ `Proto.Google.Protobuf.Compiler.Plugin`, which were previously exported+ by the `proto-lens` package.+ ## v0.5.0.0 - Bump upper bounds to support `proto-lens-0.5.*`.
proto-lens-protobuf-types.cabal view
@@ -1,13 +1,11 @@-cabal-version: 1.24+cabal-version: 2.0 --- This file has been generated from package.yaml by hpack version 0.31.1.+-- This file has been generated from package.yaml by hpack version 0.37.0. -- -- see: https://github.com/sol/hpack------ hash: 18c57260e37f835093a29151251f6193cc378187931b593a4a7751fe5d206be8 name: proto-lens-protobuf-types-version: 0.5.0.0+version: 0.7.2.3 synopsis: Basic protocol buffer message types. description: This package provides bindings standard protocol message types, for use with the proto-lens library. category: Data@@ -22,10 +20,17 @@ extra-source-files: Changelog.md proto-src/google/protobuf/any.proto+ proto-src/google/protobuf/api.proto+ proto-src/google/protobuf/compiler/plugin.proto+ proto-src/google/protobuf/descriptor.proto proto-src/google/protobuf/duration.proto proto-src/google/protobuf/empty.proto- proto-src/google/protobuf/wrappers.proto+ proto-src/google/protobuf/field_mask.proto+ proto-src/google/protobuf/source_context.proto+ proto-src/google/protobuf/struct.proto proto-src/google/protobuf/timestamp.proto+ proto-src/google/protobuf/type.proto+ proto-src/google/protobuf/wrappers.proto source-repository head type: git@@ -34,42 +39,71 @@ custom-setup setup-depends:- Cabal- , base >=4.9 && <4.13+ Cabal >=3 && <3.17+ , base >=4.10 && <4.23 , proto-lens-setup ==0.4.* library exposed-modules: Data.ProtoLens.Any+ Data.ProtoLens.Descriptor Proto.Google.Protobuf.Any Proto.Google.Protobuf.Any_Fields+ Proto.Google.Protobuf.Api+ Proto.Google.Protobuf.Api_Fields+ Proto.Google.Protobuf.Compiler.Plugin+ Proto.Google.Protobuf.Compiler.Plugin_Fields+ Proto.Google.Protobuf.Descriptor+ Proto.Google.Protobuf.Descriptor_Fields Proto.Google.Protobuf.Duration Proto.Google.Protobuf.Duration_Fields Proto.Google.Protobuf.Empty Proto.Google.Protobuf.Empty_Fields+ Proto.Google.Protobuf.FieldMask+ Proto.Google.Protobuf.FieldMask_Fields+ Proto.Google.Protobuf.SourceContext+ Proto.Google.Protobuf.SourceContext_Fields+ Proto.Google.Protobuf.Struct+ Proto.Google.Protobuf.Struct_Fields+ Proto.Google.Protobuf.Timestamp+ Proto.Google.Protobuf.Timestamp_Fields+ Proto.Google.Protobuf.Type+ Proto.Google.Protobuf.Type_Fields Proto.Google.Protobuf.Wrappers Proto.Google.Protobuf.Wrappers_Fields+ autogen-modules:+ Proto.Google.Protobuf.Any+ Proto.Google.Protobuf.Any_Fields+ Proto.Google.Protobuf.Api+ Proto.Google.Protobuf.Api_Fields+ Proto.Google.Protobuf.Compiler.Plugin+ Proto.Google.Protobuf.Compiler.Plugin_Fields+ Proto.Google.Protobuf.Descriptor+ Proto.Google.Protobuf.Descriptor_Fields+ Proto.Google.Protobuf.Duration+ Proto.Google.Protobuf.Duration_Fields+ Proto.Google.Protobuf.Empty+ Proto.Google.Protobuf.Empty_Fields+ Proto.Google.Protobuf.FieldMask+ Proto.Google.Protobuf.FieldMask_Fields+ Proto.Google.Protobuf.SourceContext+ Proto.Google.Protobuf.SourceContext_Fields+ Proto.Google.Protobuf.Struct+ Proto.Google.Protobuf.Struct_Fields Proto.Google.Protobuf.Timestamp Proto.Google.Protobuf.Timestamp_Fields- other-modules:- Paths_proto_lens_protobuf_types+ Proto.Google.Protobuf.Type+ Proto.Google.Protobuf.Type_Fields+ Proto.Google.Protobuf.Wrappers+ Proto.Google.Protobuf.Wrappers_Fields hs-source-dirs: src+ build-tool-depends:+ proto-lens-protoc:proto-lens-protoc build-depends:- base >=4.9 && <4.13- , lens-family ==1.2.*- , proto-lens ==0.5.*- , proto-lens-runtime ==0.5.*- , text ==1.2.*+ base >=4.10 && <4.23+ , lens-family >=1.2 && <2.2+ , proto-lens ==0.7.*+ , proto-lens-runtime ==0.7.*+ , text >=1.2 && <2.2 default-language: Haskell2010- autogen-modules:- Proto.Google.Protobuf.Any- Proto.Google.Protobuf.Any_Fields- Proto.Google.Protobuf.Duration- Proto.Google.Protobuf.Duration_Fields- Proto.Google.Protobuf.Empty- Proto.Google.Protobuf.Empty_Fields- Proto.Google.Protobuf.Wrappers- Proto.Google.Protobuf.Wrappers_Fields- Proto.Google.Protobuf.Timestamp- Proto.Google.Protobuf.Timestamp_Fields
proto-src/google/protobuf/any.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes";-option go_package = "github.com/golang/protobuf/ptypes/any";+option go_package = "google.golang.org/protobuf/types/known/anypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "AnyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // `Any` contains an arbitrary serialized protocol buffer message along with a // URL that describes the type of the serialized message.@@ -63,6 +63,10 @@ // if (any.is(Foo.class)) { // foo = any.unpack(Foo.class); // }+// // or ...+// if (any.isSameTypeAs(Foo.getDefaultInstance())) {+// foo = any.unpack(Foo.getDefaultInstance());+// } // // Example 3: Pack and unpack a message in Python. //@@ -77,10 +81,13 @@ // Example 4: Pack and unpack a message in Go // // foo := &pb.Foo{...}-// any, err := ptypes.MarshalAny(foo)+// any, err := anypb.New(foo)+// if err != nil {+// ...+// } // ... // foo := &pb.Foo{}-// if err := ptypes.UnmarshalAny(any, foo); err != nil {+// if err := any.UnmarshalTo(foo); err != nil { // ... // } //@@ -90,7 +97,6 @@ // 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@@ -121,7 +127,8 @@ // message Any { // A URL/resource name that uniquely identifies the type of the serialized- // protocol buffer message. The last segment of the URL's path must represent+ // protocol buffer message. This string must contain at least+ // one "/" character. 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).@@ -142,7 +149,8 @@ // // Note: this functionality is not currently available in the official // protobuf release, and it is not used for type URLs beginning with- // type.googleapis.com.+ // type.googleapis.com. As of May 2023, there are no widely used type server+ // implementations and no plans to implement one. // // Schemes other than `http`, `https` (or the empty scheme) might be // used with implementation specific semantics.
+ proto-src/google/protobuf/api.proto view
@@ -0,0 +1,207 @@+// 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_package = "com.google.protobuf";+option java_outer_classname = "ApiProto";+option java_multiple_files = true;+option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes";+option go_package = "google.golang.org/protobuf/types/known/apipb";++// Api is a light-weight descriptor for an API Interface.+//+// Interfaces are also described as "protocol buffer services" in some contexts,+// such as by the "service" keyword in a .proto file, but they are different+// from API Services, which represent a concrete implementation of an interface+// as opposed to simply a description of methods and bindings. They are also+// sometimes simply referred to as "APIs" in other contexts, such as the name of+// this message itself. See https://cloud.google.com/apis/design/glossary for+// detailed terminology.+message Api {+ // The fully qualified name of this interface, including package name+ // followed by the interface's simple name.+ string name = 1;++ // The methods of this interface, in unspecified order.+ repeated Method methods = 2;++ // Any metadata attached to the interface.+ repeated Option options = 3;++ // A version string for this interface. 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+ // interface, 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, non-GA interfaces.+ //+ string version = 4;++ // Source context for the protocol buffer service represented by this+ // message.+ SourceContext source_context = 5;++ // Included interfaces. See [Mixin][].+ repeated Mixin mixins = 6;++ // The source syntax of the service.+ Syntax syntax = 7;+}++// Method represents a method of an API interface.+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;++ // The source syntax of this method.+ Syntax syntax = 7;+}++// Declares an API Interface to be included in this interface. The including+// interface must redeclare all the methods from the included interface, 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 interface 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";+// }+// ...+// }+message Mixin {+ // The fully qualified name of the interface which is included.+ string name = 1;++ // If non-empty specifies a path under which inherited HTTP paths+ // are rooted.+ string root = 2;+}
+ proto-src/google/protobuf/compiler/plugin.proto view
@@ -0,0 +1,180 @@+// Protocol Buffers - Google's data interchange format+// Copyright 2008 Google Inc. All rights reserved.+//+// Use of this source code is governed by a BSD-style+// license that can be found in the LICENSE file or at+// https://developers.google.com/open-source/licenses/bsd++// Author: kenton@google.com (Kenton Varda)+//+// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is+// just a program that reads a CodeGeneratorRequest from stdin and writes a+// CodeGeneratorResponse to stdout.+//+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead+// of dealing with the raw protocol defined here.+//+// A plugin executable needs only to be placed somewhere in the path. The+// plugin should be named "protoc-gen-$NAME", and will then be used when the+// flag "--${NAME}_out" is passed to protoc.++syntax = "proto2";++package google.protobuf.compiler;+option java_package = "com.google.protobuf.compiler";+option java_outer_classname = "PluginProtos";++option csharp_namespace = "Google.Protobuf.Compiler";+option go_package = "google.golang.org/protobuf/types/pluginpb";++import "google/protobuf/descriptor.proto";++// The version number of protocol compiler.+message Version {+ optional int32 major = 1;+ optional int32 minor = 2;+ optional int32 patch = 3;+ // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should+ // be empty for mainline stable releases.+ optional string suffix = 4;+}++// An encoded CodeGeneratorRequest is written to the plugin's stdin.+message CodeGeneratorRequest {+ // The .proto files that were explicitly listed on the command-line. The+ // code generator should generate code only for these files. Each file's+ // descriptor will be included in proto_file, below.+ repeated string file_to_generate = 1;++ // The generator parameter passed on the command-line.+ optional string parameter = 2;++ // FileDescriptorProtos for all files in files_to_generate and everything+ // they import. The files will appear in topological order, so each file+ // appears before any file that imports it.+ //+ // Note: the files listed in files_to_generate will include runtime-retention+ // options only, but all other files will include source-retention options.+ // The source_file_descriptors field below is available in case you need+ // source-retention options for files_to_generate.+ //+ // protoc guarantees that all proto_files will be written after+ // the fields above, even though this is not technically guaranteed by the+ // protobuf wire format. This theoretically could allow a plugin to stream+ // in the FileDescriptorProtos and handle them one by one rather than read+ // the entire set into memory at once. However, as of this writing, this+ // is not similarly optimized on protoc's end -- it will store all fields in+ // memory at once before sending them to the plugin.+ //+ // Type names of fields and extensions in the FileDescriptorProto are always+ // fully qualified.+ repeated FileDescriptorProto proto_file = 15;++ // File descriptors with all options, including source-retention options.+ // These descriptors are only provided for the files listed in+ // files_to_generate.+ repeated FileDescriptorProto source_file_descriptors = 17;++ // The version number of protocol compiler.+ optional Version compiler_version = 3;+}++// The plugin writes an encoded CodeGeneratorResponse to stdout.+message CodeGeneratorResponse {+ // Error message. If non-empty, code generation failed. The plugin process+ // should exit with status code zero even if it reports an error in this way.+ //+ // This should be used to indicate errors in .proto files which prevent the+ // code generator from generating correct code. Errors which indicate a+ // problem in protoc itself -- such as the input CodeGeneratorRequest being+ // unparseable -- should be reported by writing a message to stderr and+ // exiting with a non-zero status code.+ optional string error = 1;++ // A bitmask of supported features that the code generator supports.+ // This is a bitwise "or" of values from the Feature enum.+ optional uint64 supported_features = 2;++ // Sync with code_generator.h.+ enum Feature {+ FEATURE_NONE = 0;+ FEATURE_PROTO3_OPTIONAL = 1;+ FEATURE_SUPPORTS_EDITIONS = 2;+ }++ // The minimum edition this plugin supports. This will be treated as an+ // Edition enum, but we want to allow unknown values. It should be specified+ // according the edition enum value, *not* the edition number. Only takes+ // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.+ optional int32 minimum_edition = 3;++ // The maximum edition this plugin supports. This will be treated as an+ // Edition enum, but we want to allow unknown values. It should be specified+ // according the edition enum value, *not* the edition number. Only takes+ // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.+ optional int32 maximum_edition = 4;++ // Represents a single generated file.+ message File {+ // The file name, relative to the output directory. The name must not+ // contain "." or ".." components and must be relative, not be absolute (so,+ // the file cannot lie outside the output directory). "/" must be used as+ // the path separator, not "\".+ //+ // If the name is omitted, the content will be appended to the previous+ // file. This allows the generator to break large files into small chunks,+ // and allows the generated text to be streamed back to protoc so that large+ // files need not reside completely in memory at one time. Note that as of+ // this writing protoc does not optimize for this -- it will read the entire+ // CodeGeneratorResponse before writing files to disk.+ optional string name = 1;++ // If non-empty, indicates that the named file should already exist, and the+ // content here is to be inserted into that file at a defined insertion+ // point. This feature allows a code generator to extend the output+ // produced by another code generator. The original generator may provide+ // insertion points by placing special annotations in the file that look+ // like:+ // @@protoc_insertion_point(NAME)+ // The annotation can have arbitrary text before and after it on the line,+ // which allows it to be placed in a comment. NAME should be replaced with+ // an identifier naming the point -- this is what other generators will use+ // as the insertion_point. Code inserted at this point will be placed+ // immediately above the line containing the insertion point (thus multiple+ // insertions to the same point will come out in the order they were added).+ // The double-@ is intended to make it unlikely that the generated code+ // could contain things that look like insertion points by accident.+ //+ // For example, the C++ code generator places the following line in the+ // .pb.h files that it generates:+ // // @@protoc_insertion_point(namespace_scope)+ // This line appears within the scope of the file's package namespace, but+ // outside of any particular class. Another plugin can then specify the+ // insertion_point "namespace_scope" to generate additional classes or+ // other declarations that should be placed in this scope.+ //+ // Note that if the line containing the insertion point begins with+ // whitespace, the same whitespace will be added to every line of the+ // inserted text. This is useful for languages like Python, where+ // indentation matters. In these languages, the insertion point comment+ // should be indented the same amount as any inserted code will need to be+ // in order to work correctly in that context.+ //+ // The code generator that generates the initial file and the one which+ // inserts into it must both run as part of a single invocation of protoc.+ // Code generators are executed in the order in which they appear on the+ // command line.+ //+ // If |insertion_point| is present, |name| must also be present.+ optional string insertion_point = 2;++ // The file contents.+ optional string content = 15;++ // Information describing the file content being inserted. If an insertion+ // point is used, this information will be appropriately offset and inserted+ // into the code generation metadata for the generated files.+ optional GeneratedCodeInfo generated_code_info = 16;+ }+ repeated File file = 15;+}
+ proto-src/google/protobuf/descriptor.proto view
@@ -0,0 +1,1296 @@+// 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.++// Author: kenton@google.com (Kenton Varda)+// Based on original Protocol Buffers design by+// Sanjay Ghemawat, Jeff Dean, and others.+//+// The messages in this file describe the definitions found in .proto files.+// A valid .proto file can be translated directly to a FileDescriptorProto+// without any other information (e.g. without reading its imports).++syntax = "proto2";++package google.protobuf;++option go_package = "google.golang.org/protobuf/types/descriptorpb";+option java_package = "com.google.protobuf";+option java_outer_classname = "DescriptorProtos";+option csharp_namespace = "Google.Protobuf.Reflection";+option objc_class_prefix = "GPB";+option cc_enable_arenas = true;++// descriptor.proto must be optimized for speed because reflection-based+// algorithms don't work during bootstrapping.+option optimize_for = SPEED;++// The protocol compiler can output a FileDescriptorSet containing the .proto+// files it parses.+message FileDescriptorSet {+ repeated FileDescriptorProto file = 1;+}++// The full set of known editions.+enum Edition {+ // A placeholder for an unknown edition value.+ EDITION_UNKNOWN = 0;++ // A placeholder edition for specifying default behaviors *before* a feature+ // was first introduced. This is effectively an "infinite past".+ EDITION_LEGACY = 900;++ // Legacy syntax "editions". These pre-date editions, but behave much like+ // distinct editions. These can't be used to specify the edition of proto+ // files, but feature definitions must supply proto2/proto3 defaults for+ // backwards compatibility.+ EDITION_PROTO2 = 998;+ EDITION_PROTO3 = 999;++ // Editions that have been released. The specific values are arbitrary and+ // should not be depended on, but they will always be time-ordered for easy+ // comparison.+ EDITION_2023 = 1000;+ EDITION_2024 = 1001;++ // Placeholder editions for testing feature resolution. These should not be+ // used or relyed on outside of tests.+ EDITION_1_TEST_ONLY = 1;+ EDITION_2_TEST_ONLY = 2;+ EDITION_99997_TEST_ONLY = 99997;+ EDITION_99998_TEST_ONLY = 99998;+ EDITION_99999_TEST_ONLY = 99999;++ // Placeholder for specifying unbounded edition support. This should only+ // ever be used by plugins that can expect to never require any changes to+ // support a new edition.+ EDITION_MAX = 0x7FFFFFFF;+}++// Describes a complete .proto file.+message FileDescriptorProto {+ optional string name = 1; // file name, relative to root of source tree+ optional string package = 2; // e.g. "foo", "foo.bar", etc.++ // Names of files imported by this file.+ repeated string dependency = 3;+ // Indexes of the public imported files in the dependency list above.+ repeated int32 public_dependency = 10;+ // Indexes of the weak imported files in the dependency list.+ // For Google-internal migration only. Do not use.+ repeated int32 weak_dependency = 11;++ // All top-level definitions in this file.+ repeated DescriptorProto message_type = 4;+ repeated EnumDescriptorProto enum_type = 5;+ repeated ServiceDescriptorProto service = 6;+ repeated FieldDescriptorProto extension = 7;++ optional FileOptions options = 8;++ // 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.+ optional SourceCodeInfo source_code_info = 9;++ // The syntax of the proto file.+ // The supported values are "proto2", "proto3", and "editions".+ //+ // If `edition` is present, this value must be "editions".+ optional string syntax = 12;++ // The edition of the proto file.+ optional Edition edition = 14;+}++// Describes a message type.+message DescriptorProto {+ optional string name = 1;++ repeated FieldDescriptorProto field = 2;+ repeated FieldDescriptorProto extension = 6;++ repeated DescriptorProto nested_type = 3;+ repeated EnumDescriptorProto enum_type = 4;++ message ExtensionRange {+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Exclusive.++ optional ExtensionRangeOptions options = 3;+ }+ repeated ExtensionRange extension_range = 5;++ repeated OneofDescriptorProto oneof_decl = 8;++ optional MessageOptions options = 7;++ // 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.+ message ReservedRange {+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Exclusive.+ }+ repeated ReservedRange reserved_range = 9;+ // Reserved field names, which may not be used by fields in the same message.+ // A given name may only be reserved once.+ repeated string reserved_name = 10;+}++message ExtensionRangeOptions {+ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ message Declaration {+ // The extension number declared within the extension range.+ optional int32 number = 1;++ // The fully-qualified name of the extension field. There must be a leading+ // dot in front of the full name.+ optional string full_name = 2;++ // The fully-qualified type name of the extension field. Unlike+ // Metadata.type, Declaration.type must have a leading dot for messages+ // and enums.+ optional string type = 3;++ // If true, indicates that the number is reserved in the extension range,+ // and any extension field with the number will fail to compile. Set this+ // when a declared extension field is deleted.+ optional bool reserved = 5;++ // If true, indicates that the extension must be defined as repeated.+ // Otherwise the extension must be defined as optional.+ optional bool repeated = 6;++ reserved 4; // removed is_repeated+ }++ // For external users: DO NOT USE. We are in the process of open sourcing+ // extension declaration and executing internal cleanups before it can be+ // used externally.+ repeated Declaration declaration = 2 [retention = RETENTION_SOURCE];++ // Any features defined in the specific edition.+ optional FeatureSet features = 50;++ // The verification state of the extension range.+ enum VerificationState {+ // All the extensions of the range must be declared.+ DECLARATION = 0;+ UNVERIFIED = 1;+ }++ // The verification state of the range.+ // TODO: flip the default to DECLARATION once all empty ranges+ // are marked as UNVERIFIED.+ optional VerificationState verification = 3+ [default = UNVERIFIED, retention = RETENTION_SOURCE];++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++// Describes a field within a message.+message FieldDescriptorProto {+ enum Type {+ // 0 is reserved for errors.+ // Order is weird for historical reasons.+ TYPE_DOUBLE = 1;+ TYPE_FLOAT = 2;+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if+ // negative values are likely.+ TYPE_INT64 = 3;+ TYPE_UINT64 = 4;+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if+ // negative values are likely.+ TYPE_INT32 = 5;+ TYPE_FIXED64 = 6;+ TYPE_FIXED32 = 7;+ TYPE_BOOL = 8;+ TYPE_STRING = 9;+ // Tag-delimited aggregate.+ // Group type is deprecated and not supported after google.protobuf. However, Proto3+ // implementations should still be able to parse the group wire format and+ // treat group fields as unknown fields. In Editions, the group wire format+ // can be enabled via the `message_encoding` feature.+ TYPE_GROUP = 10;+ TYPE_MESSAGE = 11; // Length-delimited aggregate.++ // New in version 2.+ TYPE_BYTES = 12;+ TYPE_UINT32 = 13;+ TYPE_ENUM = 14;+ TYPE_SFIXED32 = 15;+ TYPE_SFIXED64 = 16;+ TYPE_SINT32 = 17; // Uses ZigZag encoding.+ TYPE_SINT64 = 18; // Uses ZigZag encoding.+ }++ enum Label {+ // 0 is reserved for errors+ LABEL_OPTIONAL = 1;+ LABEL_REPEATED = 3;+ // The required label is only allowed in google.protobuf. In proto3 and Editions+ // it's explicitly prohibited. In Editions, the `field_presence` feature+ // can be used to get this behavior.+ LABEL_REQUIRED = 2;+ }++ optional string name = 1;+ optional int32 number = 3;+ optional Label label = 4;++ // 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.+ optional Type type = 5;++ // 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).+ optional string type_name = 6;++ // For extensions, this is the name of the type being extended. It is+ // resolved in the same manner as type_name.+ optional string extendee = 2;++ // 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.+ optional string default_value = 7;++ // If set, gives the index of a oneof in the containing type's oneof_decl+ // list. This field is a member of that oneof.+ optional int32 oneof_index = 9;++ // 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.+ optional string json_name = 10;++ optional FieldOptions options = 8;++ // If true, this is a proto3 "optional". When a proto3 field is optional, it+ // tracks presence regardless of field type.+ //+ // When proto3_optional is true, this field must belong to a oneof to signal+ // to old proto3 clients that presence is tracked for this field. This oneof+ // is known as a "synthetic" oneof, and this field must be its sole member+ // (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs+ // exist in the descriptor only, and do not generate any API. Synthetic oneofs+ // must be ordered after all "real" oneofs.+ //+ // For message fields, proto3_optional doesn't create any semantic change,+ // since non-repeated message fields always track presence. However it still+ // indicates the semantic detail of whether the user wrote "optional" or not.+ // This can be useful for round-tripping the .proto file. For consistency we+ // give message fields a synthetic oneof also, even though it is not required+ // to track presence. This is especially important because the parser can't+ // tell if a field is a message or an enum, so it must always create a+ // synthetic oneof.+ //+ // Proto2 optional fields do not set this flag, because they already indicate+ // optional with `LABEL_OPTIONAL`.+ optional bool proto3_optional = 17;+}++// Describes a oneof.+message OneofDescriptorProto {+ optional string name = 1;+ optional OneofOptions options = 2;+}++// Describes an enum type.+message EnumDescriptorProto {+ optional string name = 1;++ repeated EnumValueDescriptorProto value = 2;++ optional EnumOptions options = 3;++ // Range of reserved numeric values. Reserved values may not be used by+ // entries in the same enum. Reserved ranges may not overlap.+ //+ // Note that this is distinct from DescriptorProto.ReservedRange in that it+ // is inclusive such that it can appropriately represent the entire int32+ // domain.+ message EnumReservedRange {+ optional int32 start = 1; // Inclusive.+ optional int32 end = 2; // Inclusive.+ }++ // Range of reserved numeric values. Reserved numeric values may not be used+ // by enum values in the same enum declaration. Reserved ranges may not+ // overlap.+ repeated EnumReservedRange reserved_range = 4;++ // Reserved enum value names, which may not be reused. A given name may only+ // be reserved once.+ repeated string reserved_name = 5;+}++// Describes a value within an enum.+message EnumValueDescriptorProto {+ optional string name = 1;+ optional int32 number = 2;++ optional EnumValueOptions options = 3;+}++// Describes a service.+message ServiceDescriptorProto {+ optional string name = 1;+ repeated MethodDescriptorProto method = 2;++ optional ServiceOptions options = 3;+}++// Describes a method of a service.+message MethodDescriptorProto {+ optional string name = 1;++ // Input and output type names. These are resolved in the same way as+ // FieldDescriptorProto.type_name, but must refer to a message type.+ optional string input_type = 2;+ optional string output_type = 3;++ optional MethodOptions options = 4;++ // Identifies if client streams multiple client messages+ optional bool client_streaming = 5 [default = false];+ // Identifies if server streams multiple server messages+ optional bool server_streaming = 6 [default = false];+}++// ===================================================================+// Options++// Each of the definitions above may have "options" attached. These are+// just annotations which may cause code to be generated slightly differently+// or may contain hints for code that manipulates protocol messages.+//+// Clients may define custom options as extensions of the *Options messages.+// These extensions may not yet be known at parsing time, so the parser cannot+// store the values in them. Instead it stores them in a field in the *Options+// message called uninterpreted_option. This field must have the same name+// across all *Options messages. We then use this field to populate the+// extensions when we build a descriptor, at which point all protos have been+// parsed and so all extensions are known.+//+// Extension numbers for custom options may be chosen as follows:+// * For options which will only be used within a single application or+// organization, or for experimental options, use field numbers 50000+// through 99999. It is up to you to ensure that you do not use the+// same number for multiple options.+// * For options which will be published and used publicly by multiple+// independent entities, e-mail protobuf-global-extension-registry@google.com+// to reserve extension numbers. Simply provide your project name (e.g.+// Objective-C plugin) and your project website (if available) -- there's no+// need to explain how you intend to use them. Usually you only need one+// extension number. You can declare multiple options with only one extension+// number by putting them in a sub-message. See the Custom Options section of+// the docs for examples:+// https://developers.google.com/protocol-buffers/docs/proto#options+// If this turns out to be popular, a web service will be set up+// to automatically assign option numbers.++message FileOptions {++ // 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.+ optional string java_package = 1;++ // Controls the name of the wrapper Java class generated for the .proto file.+ // That class will always contain the .proto file's getDescriptor() method as+ // well as any top-level extensions defined in the .proto file.+ // If java_multiple_files is disabled, then all the other classes from the+ // .proto file will be nested inside the single wrapper outer class.+ optional string java_outer_classname = 8;++ // If enabled, 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 wrapper class+ // named by java_outer_classname. However, the wrapper class will still be+ // generated to contain the file's getDescriptor() method as well as any+ // top-level extensions defined in the file.+ optional bool java_multiple_files = 10 [default = false];++ // This option does nothing.+ optional bool java_generate_equals_and_hash = 20 [deprecated=true];++ // A proto2 file can set this to true to opt in to UTF-8 checking for Java,+ // which will throw an exception if invalid UTF-8 is parsed from the wire or+ // assigned to a string field.+ //+ // TODO: clarify exactly what kinds of field types this option+ // applies to, and update these docs accordingly.+ //+ // Proto3 files already perform these checks. Setting the option explicitly to+ // false has no effect: it cannot be used to opt proto3 files out of UTF-8+ // checks.+ optional bool java_string_check_utf8 = 27 [default = false];++ // Generated classes can be optimized for speed or code size.+ enum OptimizeMode {+ SPEED = 1; // Generate complete code for parsing, serialization,+ // etc.+ CODE_SIZE = 2; // Use ReflectionOps to implement these methods.+ LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.+ }+ optional OptimizeMode optimize_for = 9 [default = SPEED];++ // 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.+ optional string go_package = 11;++ // 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.+ optional bool cc_generic_services = 16 [default = false];+ optional bool java_generic_services = 17 [default = false];+ optional bool py_generic_services = 18 [default = false];+ reserved 42; // removed php_generic_services+ reserved "php_generic_services";++ // 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.+ optional bool deprecated = 23 [default = false];++ // Enables the use of arenas for the proto messages in this file. This applies+ // only to generated classes for C++.+ optional bool cc_enable_arenas = 31 [default = true];++ // Sets the objective c class prefix which is prepended to all objective c+ // generated classes from this .proto. There is no default.+ optional string objc_class_prefix = 36;++ // Namespace for generated classes; defaults to the package.+ optional string csharp_namespace = 37;++ // By default Swift generators will take the proto package and CamelCase it+ // replacing '.' with underscore and use that to prefix the types/symbols+ // defined. When this options is provided, they will use this value instead+ // to prefix the types/symbols defined.+ optional string swift_prefix = 39;++ // Sets the php class prefix which is prepended to all php generated classes+ // from this .proto. Default is empty.+ optional string php_class_prefix = 40;++ // Use this option to change the namespace of php generated classes. Default+ // is empty. When this option is empty, the package name will be used for+ // determining the namespace.+ optional string php_namespace = 41;++ // Use this option to change the namespace of php generated metadata classes.+ // Default is empty. When this option is empty, the proto file name will be+ // used for determining the namespace.+ optional string php_metadata_namespace = 44;++ // Use this option to change the package of ruby generated classes. Default+ // is empty. When this option is not set, the package name will be used for+ // determining the ruby package.+ optional string ruby_package = 45;++ // Any features defined in the specific edition.+ optional FeatureSet features = 50;++ // The parser stores options it doesn't recognize here.+ // See the documentation for the "Options" section above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message.+ // See the documentation for the "Options" section above.+ extensions 1000 to max;++ reserved 38;+}++message MessageOptions {+ // 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.+ optional bool message_set_wire_format = 1 [default = false];++ // 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".+ optional bool no_standard_descriptor_accessor = 2 [default = false];++ // 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.+ optional bool deprecated = 3 [default = false];++ reserved 4, 5, 6;++ // 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 implementations 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.+ optional bool map_entry = 7;++ reserved 8; // javalite_serializable+ reserved 9; // javanano_as_lite++ // Enable the legacy handling of JSON field name conflicts. This lowercases+ // and strips underscored from the fields before comparison in proto3 only.+ // The new behavior takes `json_name` into account and applies to proto2 as+ // well.+ //+ // This should only be used as a temporary measure against broken builds due+ // to the change in behavior for JSON field name conflicts.+ //+ // TODO This is legacy behavior we plan to remove once downstream+ // teams have had time to migrate.+ optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true];++ // Any features defined in the specific edition.+ optional FeatureSet features = 12;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message FieldOptions {+ // NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead.+ // 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 only implemented to support use of+ // [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of+ // type "bytes" in the open source release.+ // TODO: make ctype actually deprecated.+ optional CType ctype = 1 [/*deprecated = true,*/ default = STRING];+ enum CType {+ // Default mode.+ STRING = 0;++ // The option [ctype=CORD] may be applied to a non-repeated field of type+ // "bytes". It indicates that in C++, the data should be stored in a Cord+ // instead of a string. For very large strings, this may reduce memory+ // fragmentation. It may also allow better performance when parsing from a+ // Cord, or when parsing with aliasing enabled, as the parsed Cord may then+ // alias the original buffer.+ CORD = 1;++ STRING_PIECE = 2;+ }+ // 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. This option is prohibited in+ // Editions, but the `repeated_field_encoding` feature can be used to control+ // the behavior.+ optional bool packed = 2;++ // 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). A field with jstype JS_STRING+ // is represented as JavaScript string, which avoids loss of precision that+ // can happen when a large value is converted to a floating point JavaScript.+ // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to+ // use the JavaScript "number" type. The behavior of the default option+ // JS_NORMAL is implementation dependent.+ //+ // This option is an enum to permit additional types to be added, e.g.+ // goog.math.Integer.+ optional JSType jstype = 6 [default = JS_NORMAL];+ enum JSType {+ // Use the default type.+ JS_NORMAL = 0;++ // Use JavaScript strings.+ JS_STRING = 1;++ // Use JavaScript numbers.+ JS_NUMBER = 2;+ }++ // 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 lazy message fields are still eagerly verified to check+ // ill-formed wireformat or missing required fields. Calling IsInitialized()+ // on the outer message would fail if the inner message has missing required+ // fields. Failed verification would result in parsing failure (except when+ // uninitialized messages are acceptable).+ optional bool lazy = 5 [default = false];++ // unverified_lazy does no correctness checks on the byte stream. This should+ // only be used where lazy with verification is prohibitive for performance+ // reasons.+ optional bool unverified_lazy = 15 [default = false];++ // 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.+ optional bool deprecated = 3 [default = false];++ // For Google-internal migration only. Do not use.+ optional bool weak = 10 [default = false];++ // Indicate that the field value should not be printed out when using debug+ // formats, e.g. when the field contains sensitive credentials.+ optional bool debug_redact = 16 [default = false];++ // If set to RETENTION_SOURCE, the option will be omitted from the binary.+ // Note: as of January 2023, support for this is in progress and does not yet+ // have an effect (b/264593489).+ enum OptionRetention {+ RETENTION_UNKNOWN = 0;+ RETENTION_RUNTIME = 1;+ RETENTION_SOURCE = 2;+ }++ optional OptionRetention retention = 17;++ // This indicates the types of entities that the field may apply to when used+ // as an option. If it is unset, then the field may be freely used as an+ // option on any kind of entity. Note: as of January 2023, support for this is+ // in progress and does not yet have an effect (b/264593489).+ enum OptionTargetType {+ TARGET_TYPE_UNKNOWN = 0;+ TARGET_TYPE_FILE = 1;+ TARGET_TYPE_EXTENSION_RANGE = 2;+ TARGET_TYPE_MESSAGE = 3;+ TARGET_TYPE_FIELD = 4;+ TARGET_TYPE_ONEOF = 5;+ TARGET_TYPE_ENUM = 6;+ TARGET_TYPE_ENUM_ENTRY = 7;+ TARGET_TYPE_SERVICE = 8;+ TARGET_TYPE_METHOD = 9;+ }++ repeated OptionTargetType targets = 19;++ message EditionDefault {+ optional Edition edition = 3;+ optional string value = 2; // Textproto value.+ }+ repeated EditionDefault edition_defaults = 20;++ // Any features defined in the specific edition.+ optional FeatureSet features = 21;++ // Information about the support window of a feature.+ message FeatureSupport {+ // The edition that this feature was first available in. In editions+ // earlier than this one, the default assigned to EDITION_LEGACY will be+ // used, and proto files will not be able to override it.+ optional Edition edition_introduced = 1;++ // The edition this feature becomes deprecated in. Using this after this+ // edition may trigger warnings.+ optional Edition edition_deprecated = 2;++ // The deprecation warning text if this feature is used after the edition it+ // was marked deprecated in.+ optional string deprecation_warning = 3;++ // The edition this feature is no longer available in. In editions after+ // this one, the last default assigned will be used, and proto files will+ // not be able to override it.+ optional Edition edition_removed = 4;+ }+ optional FeatureSupport feature_support = 22;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;++ reserved 4; // removed jtype+ reserved 18; // reserve target, target_obsolete_do_not_use+}++message OneofOptions {+ // Any features defined in the specific edition.+ optional FeatureSet features = 1;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message EnumOptions {++ // Set this option to true to allow mapping different tag names to the same+ // value.+ optional bool allow_alias = 2;++ // 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.+ optional bool deprecated = 3 [default = false];++ reserved 5; // javanano_as_lite++ // Enable the legacy handling of JSON field name conflicts. This lowercases+ // and strips underscored from the fields before comparison in proto3 only.+ // The new behavior takes `json_name` into account and applies to proto2 as+ // well.+ // TODO Remove this legacy behavior once downstream teams have+ // had time to migrate.+ optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];++ // Any features defined in the specific edition.+ optional FeatureSet features = 7;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message EnumValueOptions {+ // 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.+ optional bool deprecated = 1 [default = false];++ // Any features defined in the specific edition.+ optional FeatureSet features = 2;++ // Indicate that fields annotated with this enum value should not be printed+ // out when using debug formats, e.g. when the field contains sensitive+ // credentials.+ optional bool debug_redact = 3 [default = false];++ // Information about the support window of a feature value.+ optional FieldOptions.FeatureSupport feature_support = 4;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message ServiceOptions {++ // Any features defined in the specific edition.+ optional FeatureSet features = 34;++ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC+ // framework. We apologize for hoarding these numbers to ourselves, but+ // we were already using them long before we decided to release Protocol+ // Buffers.++ // 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.+ optional bool deprecated = 33 [default = false];++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message MethodOptions {++ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC+ // framework. We apologize for hoarding these numbers to ourselves, but+ // we were already using them long before we decided to release Protocol+ // Buffers.++ // 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.+ optional bool deprecated = 33 [default = false];++ // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,+ // or neither? HTTP based RPC implementation may choose GET verb for safe+ // methods, and PUT verb for idempotent methods instead of the default POST.+ enum IdempotencyLevel {+ IDEMPOTENCY_UNKNOWN = 0;+ NO_SIDE_EFFECTS = 1; // implies idempotent+ IDEMPOTENT = 2; // idempotent, but may have side effects+ }+ optional IdempotencyLevel idempotency_level = 34+ [default = IDEMPOTENCY_UNKNOWN];++ // Any features defined in the specific edition.+ optional FeatureSet features = 35;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++// 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.+message UninterpretedOption {+ // 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], ["moo", false] } represents+ // "foo.(bar.baz).moo".+ message NamePart {+ required string name_part = 1;+ required bool is_extension = 2;+ }+ repeated NamePart name = 2;++ // The value of the uninterpreted option, in whatever type the tokenizer+ // identified it as during parsing. Exactly one of these should be set.+ optional string identifier_value = 3;+ optional uint64 positive_int_value = 4;+ optional int64 negative_int_value = 5;+ optional double double_value = 6;+ optional bytes string_value = 7;+ optional string aggregate_value = 8;+}++// ===================================================================+// Features++// TODO Enums in C++ gencode (and potentially other languages) are+// not well scoped. This means that each of the feature enums below can clash+// with each other. The short names we've chosen maximize call-site+// readability, but leave us very open to this scenario. A future feature will+// be designed and implemented to handle this, hopefully before we ever hit a+// conflict here.+message FeatureSet {+ enum FieldPresence {+ FIELD_PRESENCE_UNKNOWN = 0;+ EXPLICIT = 1;+ IMPLICIT = 2;+ LEGACY_REQUIRED = 3;+ }+ optional FieldPresence field_presence = 1 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "EXPLICIT" },+ edition_defaults = { edition: EDITION_PROTO3, value: "IMPLICIT" },+ edition_defaults = { edition: EDITION_2023, value: "EXPLICIT" }+ ];++ enum EnumType {+ ENUM_TYPE_UNKNOWN = 0;+ OPEN = 1;+ CLOSED = 2;+ }+ optional EnumType enum_type = 2 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_ENUM,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "CLOSED" },+ edition_defaults = { edition: EDITION_PROTO3, value: "OPEN" }+ ];++ enum RepeatedFieldEncoding {+ REPEATED_FIELD_ENCODING_UNKNOWN = 0;+ PACKED = 1;+ EXPANDED = 2;+ }+ optional RepeatedFieldEncoding repeated_field_encoding = 3 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "EXPANDED" },+ edition_defaults = { edition: EDITION_PROTO3, value: "PACKED" }+ ];++ enum Utf8Validation {+ UTF8_VALIDATION_UNKNOWN = 0;+ VERIFY = 2;+ NONE = 3;+ reserved 1;+ }+ optional Utf8Validation utf8_validation = 4 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "NONE" },+ edition_defaults = { edition: EDITION_PROTO3, value: "VERIFY" }+ ];++ enum MessageEncoding {+ MESSAGE_ENCODING_UNKNOWN = 0;+ LENGTH_PREFIXED = 1;+ DELIMITED = 2;+ }+ optional MessageEncoding message_encoding = 5 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_FIELD,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "LENGTH_PREFIXED" }+ ];++ enum JsonFormat {+ JSON_FORMAT_UNKNOWN = 0;+ ALLOW = 1;+ LEGACY_BEST_EFFORT = 2;+ }+ optional JsonFormat json_format = 6 [+ retention = RETENTION_RUNTIME,+ targets = TARGET_TYPE_MESSAGE,+ targets = TARGET_TYPE_ENUM,+ targets = TARGET_TYPE_FILE,+ feature_support = {+ edition_introduced: EDITION_2023,+ },+ edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY_BEST_EFFORT" },+ edition_defaults = { edition: EDITION_PROTO3, value: "ALLOW" }+ ];++ reserved 999;++ extensions 1000 to 9994 [+ declaration = {+ number: 1000,+ full_name: ".pb.cpp",+ type: ".pb.CppFeatures"+ },+ declaration = {+ number: 1001,+ full_name: ".pb.java",+ type: ".pb.JavaFeatures"+ },+ declaration = { number: 1002, full_name: ".pb.go", type: ".pb.GoFeatures" },+ declaration = {+ number: 9990,+ full_name: ".pb.proto1",+ type: ".pb.Proto1Features"+ }+ ];++ extensions 9995 to 9999; // For internal testing+ extensions 10000; // for https://github.com/bufbuild/protobuf-es+}++// A compiled specification for the defaults of a set of features. These+// messages are generated from FeatureSet extensions and can be used to seed+// feature resolution. The resolution with this object becomes a simple search+// for the closest matching edition, followed by proto merges.+message FeatureSetDefaults {+ // A map from every known edition with a unique set of defaults to its+ // defaults. Not all editions may be contained here. For a given edition,+ // the defaults at the closest matching edition ordered at or before it should+ // be used. This field must be in strict ascending order by edition.+ message FeatureSetEditionDefault {+ optional Edition edition = 3;++ // Defaults of features that can be overridden in this edition.+ optional FeatureSet overridable_features = 4;++ // Defaults of features that can't be overridden in this edition.+ optional FeatureSet fixed_features = 5;++ reserved 1, 2;+ reserved "features";+ }+ repeated FeatureSetEditionDefault defaults = 1;++ // The minimum supported edition (inclusive) when this was constructed.+ // Editions before this will not have defaults.+ optional Edition minimum_edition = 4;++ // The maximum known edition (inclusive) when this was constructed. Editions+ // after this will not have reliable defaults.+ optional Edition maximum_edition = 5;+}++// ===================================================================+// Optional source code info++// Encapsulates information about the original source file from which a+// FileDescriptorProto was generated.+message SourceCodeInfo {+ // 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 descendant. 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.+ repeated Location location = 1;+ message Location {+ // 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 appears.+ // 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).+ repeated int32 path = 1 [packed = true];++ // 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.+ repeated int32 span = 2 [packed = true];++ // 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 moo.+ // //+ // // Another line attached to moo.+ // optional double moo = 4;+ //+ // // Detached comment for corge. This is not leading or trailing comments+ // // to moo 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.+ optional string leading_comments = 3;+ optional string trailing_comments = 4;+ repeated string leading_detached_comments = 6;+ }+}++// 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.+message GeneratedCodeInfo {+ // An Annotation connects some span of text in generated code to an element+ // of its generating .proto file.+ repeated Annotation annotation = 1;+ message Annotation {+ // Identifies the element in the original source .proto file. This field+ // is formatted the same as SourceCodeInfo.Location.path.+ repeated int32 path = 1 [packed = true];++ // Identifies the filesystem path to the original source .proto.+ optional string source_file = 2;++ // Identifies the starting offset in bytes in the generated code+ // that relates to the identified object.+ optional int32 begin = 3;++ // Identifies the ending offset in bytes in the generated code that+ // relates to the identified object. The end offset should be one past+ // the last relevant byte (so the length of the text = end - begin).+ optional int32 end = 4;++ // Represents the identified object's effect on the element in the original+ // .proto file.+ enum Semantic {+ // There is no effect or the effect is indescribable.+ NONE = 0;+ // The element is set or otherwise mutated.+ SET = 1;+ // An alias to the element is returned.+ ALIAS = 2;+ }+ optional Semantic semantic = 5;+ }+}
proto-src/google/protobuf/duration.proto view
@@ -32,13 +32,13 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true;-option go_package = "github.com/golang/protobuf/ptypes/duration";+option go_package = "google.golang.org/protobuf/types/known/durationpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "DurationProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // A Duration represents a signed, fixed-length span of time represented // as a count of seconds and fractions of seconds at nanosecond@@ -61,7 +61,7 @@ // if (duration.seconds < 0 && duration.nanos > 0) { // duration.seconds += 1; // duration.nanos -= 1000000000;-// } else if (durations.seconds > 0 && duration.nanos < 0) {+// } else if (duration.seconds > 0 && duration.nanos < 0) { // duration.seconds -= 1; // duration.nanos += 1000000000; // }@@ -99,9 +99,7 @@ // be expressed in JSON format as "3.000000001s", and 3 seconds and 1 // microsecond should be expressed in JSON format as "3.000001s". //-// message Duration {- // Signed seconds of the span of time. Must be from -315,576,000,000 // to +315,576,000,000 inclusive. Note: these bounds are computed from: // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
proto-src/google/protobuf/empty.proto view
@@ -32,12 +32,12 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes";-option go_package = "github.com/golang/protobuf/ptypes/empty";+option go_package = "google.golang.org/protobuf/types/known/emptypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "EmptyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; // A generic empty message that you can re-use to avoid defining duplicated@@ -48,5 +48,4 @@ // rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); // } //-// The JSON representation for `Empty` is empty JSON object `{}`. message Empty {}
+ proto-src/google/protobuf/field_mask.proto view
@@ -0,0 +1,245 @@+// 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_package = "com.google.protobuf";+option java_outer_classname = "FieldMaskProto";+option java_multiple_files = true;+option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes";+option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb";+option cc_enable_arenas = true;++// `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+// paths string.+//+// 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, new values will+// be appended to the existing repeated field in the target resource. Note that+// a repeated field is only allowed in the last position of a `paths` string.+//+// If a sub-message is specified in the last position of the field mask for an+// update operation, then new value will be merged into the existing sub-message+// in the target resource.+//+// For example, given the target message:+//+// f {+// b {+// d: 1+// x: 2+// }+// c: [1]+// }+//+// And an update message:+//+// f {+// b {+// d: 10+// }+// c: [2]+// }+//+// then if the field mask is:+//+// paths: ["f.b", "f.c"]+//+// then the result will be:+//+// f {+// b {+// d: 10+// x: 2+// }+// c: [1, 2]+// }+//+// An implementation may provide options to override this default behavior for+// repeated and message fields.+//+// 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 Mask Verification+//+// The implementation of any API method which has a FieldMask type field in the+// request should verify the included field paths, and return an+// `INVALID_ARGUMENT` error if any path is unmappable.+message FieldMask {+ // The set of field mask paths.+ repeated string paths = 1;+}
+ proto-src/google/protobuf/source_context.proto view
@@ -0,0 +1,48 @@+// 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_package = "com.google.protobuf";+option java_outer_classname = "SourceContextProto";+option java_multiple_files = true;+option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes";+option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb";++// `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_context.proto"`.+ string file_name = 1;+}
+ proto-src/google/protobuf/struct.proto view
@@ -0,0 +1,95 @@+// 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 cc_enable_arenas = true;+option go_package = "google.golang.org/protobuf/types/known/structpb";+option java_package = "com.google.protobuf";+option java_outer_classname = "StructProto";+option java_multiple_files = true;+option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes";++// `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.+message Struct {+ // Unordered map of dynamically typed values.+ map<string, Value> fields = 1;+}++// `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 these+// variants. Absence of any variant indicates an error.+//+// The JSON representation for `Value` is JSON value.+message Value {+ // The kind of 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;+ }+}++// `NullValue` is a singleton enumeration to represent the null value for the+// `Value` type union.+//+// The JSON representation for `NullValue` is JSON `null`.+enum NullValue {+ // Null value.+ NULL_VALUE = 0;+}++// `ListValue` is a wrapper around a repeated field of values.+//+// The JSON representation for `ListValue` is JSON array.+message ListValue {+ // Repeated field of dynamically typed values.+ repeated Value values = 1;+}
proto-src/google/protobuf/timestamp.proto view
@@ -32,26 +32,28 @@ package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true;-option go_package = "github.com/golang/protobuf/ptypes/timestamp";+option go_package = "google.golang.org/protobuf/types/known/timestamppb"; option java_package = "com.google.protobuf"; option java_outer_classname = "TimestampProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -// 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).+// A Timestamp represents a point in time independent of any time zone or local+// calendar, encoded as a count of seconds and fractions of seconds at+// nanosecond resolution. The count is relative to an epoch at UTC midnight on+// January 1, 1970, in the proleptic Gregorian calendar which extends the+// Gregorian calendar backwards to year one. //+// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap+// second table is needed for interpretation, using a [24-hour linear+// smear](https://developers.google.com/time/smear).+//+// The 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](https://www.ietf.org/rfc/rfc3339.txt) date strings.+// // # Examples // // Example 1: Compute Timestamp from POSIX `time()`.@@ -88,9 +90,16 @@ // Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) // .setNanos((int) ((millis % 1000) * 1000000)).build(); //+// Example 5: Compute Timestamp from Java `Instant.now()`. //-// Example 5: Compute Timestamp from current time in Python.+// Instant now = Instant.now(); //+// Timestamp timestamp =+// Timestamp.newBuilder().setSeconds(now.getEpochSecond())+// .setNanos(now.getNano()).build();+//+// Example 6: Compute Timestamp from current time in Python.+// // timestamp = Timestamp() // timestamp.GetCurrentTime() //@@ -111,17 +120,17 @@ // 01:30 UTC on January 15, 2017. // // In JavaScript, one can convert a Date object to this format using the-// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]+// standard+// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) // method. In Python, a standard `datetime.datetime` object can be converted-// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)-// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one-// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](-// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--+// to this format using+// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with+// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use+// the Joda Time's [`ISODateTimeFormat.dateTime()`](+// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() // ) to obtain a formatter capable of generating timestamps in this format. //-// message Timestamp {- // Represents seconds of UTC time since Unix epoch // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to // 9999-12-31T23:59:59Z inclusive.
+ proto-src/google/protobuf/type.proto view
@@ -0,0 +1,193 @@+// 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 cc_enable_arenas = true;+option java_package = "com.google.protobuf";+option java_outer_classname = "TypeProto";+option java_multiple_files = true;+option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes";+option go_package = "google.golang.org/protobuf/types/known/typepb";++// A protocol buffer message type.+message Type {+ // The fully qualified message name.+ string name = 1;+ // The list of fields.+ repeated Field fields = 2;+ // The list of types appearing in `oneof` definitions in this type.+ repeated string oneofs = 3;+ // The protocol buffer options.+ repeated Option options = 4;+ // The source context.+ SourceContext source_context = 5;+ // The source syntax.+ Syntax syntax = 6;+ // The source edition string, only valid when syntax is SYNTAX_EDITIONS.+ string edition = 7;+}++// A single field of a message type.+message Field {+ // Basic field types.+ 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 group. Proto2 syntax only, and deprecated.+ TYPE_GROUP = 10;+ // 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;+ }++ // Whether a field is optional, required, or repeated.+ enum Cardinality {+ // For fields with unknown cardinality.+ CARDINALITY_UNKNOWN = 0;+ // For optional fields.+ CARDINALITY_OPTIONAL = 1;+ // For required fields. Proto2 syntax only.+ CARDINALITY_REQUIRED = 2;+ // For repeated fields.+ CARDINALITY_REPEATED = 3;+ }++ // The field type.+ Kind kind = 1;+ // The field cardinality.+ Cardinality cardinality = 2;+ // The field number.+ int32 number = 3;+ // The field name.+ string name = 4;+ // The field type URL, without the scheme, for message or enumeration+ // types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.+ string type_url = 6;+ // 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.+ int32 oneof_index = 7;+ // Whether to use alternative packed wire representation.+ bool packed = 8;+ // The protocol buffer options.+ repeated Option options = 9;+ // The field JSON name.+ string json_name = 10;+ // The string value of the default value of this field. Proto2 syntax only.+ string default_value = 11;+}++// Enum type definition.+message Enum {+ // Enum type name.+ string name = 1;+ // Enum value definitions.+ repeated EnumValue enumvalue = 2;+ // Protocol buffer options.+ repeated Option options = 3;+ // The source context.+ SourceContext source_context = 4;+ // The source syntax.+ Syntax syntax = 5;+ // The source edition string, only valid when syntax is SYNTAX_EDITIONS.+ string edition = 6;+}++// Enum value definition.+message EnumValue {+ // Enum value name.+ string name = 1;+ // Enum value number.+ int32 number = 2;+ // Protocol buffer options.+ repeated Option options = 3;+}++// A protocol buffer option, which can be attached to a message, field,+// enumeration, etc.+message Option {+ // The option's name. For protobuf built-in options (options defined in+ // descriptor.proto), this is the short name. For example, `"map_entry"`.+ // For custom options, it should be the fully-qualified name. For example,+ // `"google.api.http"`.+ string name = 1;+ // The option's value packed in an Any message. If the value is a primitive,+ // the corresponding wrapper type defined in google/protobuf/wrappers.proto+ // should be used. If the value is an enum, it should be stored as an int32+ // value using the google.protobuf.Int32Value type.+ Any value = 2;+}++// The syntax in which a protocol buffer element is defined.+enum Syntax {+ // Syntax `proto2`.+ SYNTAX_PROTO2 = 0;+ // Syntax `proto3`.+ SYNTAX_PROTO3 = 1;+ // Syntax `editions`.+ SYNTAX_EDITIONS = 2;+}
proto-src/google/protobuf/wrappers.proto view
@@ -27,23 +27,28 @@ // 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.-+// // Wrappers for primitive (non-message) types. These types are useful // for embedding primitives in the `google.protobuf.Any` type and for places // where we need to distinguish between the absence of a primitive // typed field and its default value.+//+// These wrappers have no meaningful use within repeated fields as they lack+// the ability to detect presence on individual elements.+// These wrappers have no meaningful use within a map or a oneof since+// individual entries of a map or fields of a oneof can already detect presence. syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true;-option go_package = "github.com/golang/protobuf/ptypes/wrappers";+option go_package = "google.golang.org/protobuf/types/known/wrapperspb"; option java_package = "com.google.protobuf"; option java_outer_classname = "WrappersProto"; option java_multiple_files = true; option objc_class_prefix = "GPB";+option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // Wrapper message for `double`. //
src/Data/ProtoLens/Any.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-}@@ -11,20 +11,21 @@ ) where import Control.Exception (Exception(..))-import Data.Monoid ((<>))+#if !MIN_VERSION_base(4,11,0)+import Data.Semigroup ((<>))+#endif import qualified Data.Text as Text import Data.Text (Text)-import Data.Typeable (Typeable) import Data.ProtoLens ( decodeMessage , defMessage , encodeMessage , Message(..) )-import Data.ProtoLens.Labels () import Data.Proxy (Proxy(..)) import Lens.Family2 ((&), (.~), (^.)) import Proto.Google.Protobuf.Any+import Proto.Google.Protobuf.Any_Fields (typeUrl, value) -- | Packs the given message into an 'Any' using the default type URL prefix -- "type.googleapis.com".@@ -38,8 +39,8 @@ packWithPrefix :: forall a . Message a => Text -> a -> Any packWithPrefix prefix x = defMessage- & #typeUrl .~ (prefix <> "/" <> name)- & #value .~ encodeMessage x+ & typeUrl .~ (prefix <> "/" <> name)+ & value .~ encodeMessage x where name = messageName (Proxy @a) @@ -51,7 +52,7 @@ , actualUrl :: Text -- ^ The typeUrl in the 'Any' being unpacked } | DecodingError Text -- ^ The error from decodeMessage- deriving (Show, Eq, Typeable)+ deriving (Show, Eq) instance Exception UnpackError @@ -61,12 +62,12 @@ -- Ignores the type URL prefix. unpack :: forall a . Message a => Any -> Either UnpackError a unpack a- | expectedName /= snd (Text.breakOnEnd "/" $ a ^. #typeUrl)+ | expectedName /= snd (Text.breakOnEnd "/" $ a ^. typeUrl) = Left DifferentType { expectedMessageType = expectedName- , actualUrl = a ^. #typeUrl+ , actualUrl = a ^. typeUrl }- | otherwise = case decodeMessage (a ^. #value) of+ | otherwise = case decodeMessage (a ^. value) of Left e -> Left $ DecodingError $ Text.pack e Right x -> Right x where
+ src/Data/ProtoLens/Descriptor.hs view
@@ -0,0 +1,43 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+-- | Functions for interacting with message descriptors.+module Data.ProtoLens.Descriptor+ ( DescriptorProto+ , messageDescriptor+ , serviceDescriptor+ , fileDescriptor+ ) where++import Data.ProtoLens+import Data.ProtoLens.Service.Types+import Data.Proxy (Proxy(..))+import Proto.Google.Protobuf.Descriptor++-- | The protocol buffer message descriptor for a given type.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > messageDescriptor @SomeProtoType+messageDescriptor :: forall a . Message a => DescriptorProto+-- Note: technically decodeMessageOrDie can fail. However, it's+-- unlikely in practice since we encode the message ourselves+-- in proto-lens-protoc; and furthermore proto decoding is robust+-- to unknown/missing fields.+messageDescriptor = decodeMessageOrDie $ packedMessageDescriptor (Proxy @a)++-- | The protocol buffer service descriptor for a given service.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > serviceDescriptor @SomeService+serviceDescriptor :: forall a . Service a => ServiceDescriptorProto+serviceDescriptor = decodeMessageOrDie $ packedServiceDescriptor (Proxy @a)++-- | The protocol buffer file descriptor containing a given type.+--+-- This function should be used with @TypeApplications@, e.g.:+--+-- > fileDescriptor @SomeProtoType+fileDescriptor :: forall a . Message a => FileDescriptorProto+fileDescriptor = decodeMessageOrDie $ packedFileDescriptor (Proxy @a)