diff --git a/Changelog.md b/Changelog.md --- a/Changelog.md +++ b/Changelog.md @@ -1,6 +1,22 @@ # Changelog for `proto-lens` -## Unreleased changes +## v0.3.0.0 +- Remove support for `ghc-7.10`. (#136) +- Use a `.cabal` file that's auto-generated from `hpack`. (#138) +- Add buildMessageDelimited: size-delimited streams of Messages (#102) +- Add support for parsing `Any` messages in google protobuf text format (#124) +- Use the Tag newtype consistently. (#127) +- Add support for tracking unknown fields. (#129) +- Improve an error message. (#132) +- Bundle enum pattern synonyms with their type. (#136) +- Implement proto3-style "open" enums. (#137) +- Consolidate `proto-lens-descriptors` into `proto-lens`. (#140) +- Split the `Message` class into separate methods. (#139) +- Improve an error message when decoding Anys. (#146) +- Refactor the `FieldDescriptorType. (#147) +- Improve text format error messages. (#148) +- Add module `Data.ProtoLens.Service.Types`. (#154) +- Add Haddock comments to fields. (#172) ## v0.2.2.0 - Bump the dependency on `base` to support `ghc-8.2.1`. diff --git a/proto-lens-imports/google/protobuf/compiler/plugin.proto b/proto-lens-imports/google/protobuf/compiler/plugin.proto new file mode 100644 --- /dev/null +++ b/proto-lens-imports/google/protobuf/compiler/plugin.proto @@ -0,0 +1,150 @@ +// 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) +// +// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to +// change. +// +// 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 go_package = "plugin_go"; + +import "google/protobuf/descriptor.proto"; + +// 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. + // + // 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. + repeated FileDescriptorProto proto_file = 15; +} + +// 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; + + // 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; + } + repeated File file = 15; +} diff --git a/proto-lens-imports/google/protobuf/descriptor.proto b/proto-lens-imports/google/protobuf/descriptor.proto new file mode 100644 --- /dev/null +++ b/proto-lens-imports/google/protobuf/descriptor.proto @@ -0,0 +1,803 @@ +// 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 = "descriptor"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DescriptorProtos"; +option csharp_namespace = "Google.Protobuf.Reflection"; +option objc_class_prefix = "GPB"; + +// 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; +} + +// 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" and "proto3". + optional string syntax = 12; +} + +// 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; + optional int32 end = 2; + } + 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; +} + +// 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; + TYPE_GROUP = 10; // Tag-delimited aggregate. + 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_REQUIRED = 2; + LABEL_REPEATED = 3; + // TODO(sanjay): Should we add LABEL_MAP? + }; + + 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. + // TODO(kenton): Base-64 encode? + 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; +} + +// Describes a oneof. +message OneofDescriptorProto { + optional string name = 1; +} + +// Describes an enum type. +message EnumDescriptorProto { + optional string name = 1; + + repeated EnumValueDescriptorProto value = 2; + + optional EnumOptions options = 3; +} + +// 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; + + + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + optional string java_outer_classname = 8; + + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + optional bool java_multiple_files = 10 [default=false]; + + // If set true, then the Java code generator will generate equals() and + // hashCode() methods for all messages defined in the .proto file. + // This increases generated code size, potentially substantially for large + // protos, which may harm a memory-constrained application. + // - In the full runtime this is a speed optimization, as the + // AbstractMessage base class includes reflection-based implementations of + // these methods. + // - In the lite runtime, setting this option changes the semantics of + // equals() and hashCode() to more closely match those of the full runtime; + // the generated methods compute their results based on field values rather + // than object identity. (Implementations should not assume that hashcodes + // will be consistent across runtimes or versions of the protocol compiler.) + optional bool java_generate_equals_and_hash = 20 [default=false]; + + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + 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]; + + // 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=false]; + + + // 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; + + // 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 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]; + + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + optional bool map_entry = 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 FieldOptions { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + optional CType ctype = 1 [default = STRING]; + enum CType { + // Default mode. + STRING = 0; + + 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. + 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). By default these types are + // represented as JavaScript strings. This avoids loss of precision that can + // happen when a large value is converted to a floating point JavaScript + // numbers. Specifying JS_NUMBER for the jstype causes the generated + // JavaScript code to use the JavaScript "number" type instead of strings. + // This option is an enum to permit additional types to be added, + // e.g. goog.math.Integer. + 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 implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outher message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + optional bool lazy = 5 [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]; + + + // 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]; + + // 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]; + + // 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 { + + // 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]; + + // 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], ["qux", false] } represents + // "foo.(bar.baz).qux". + 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; +} + +// =================================================================== +// 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 descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + 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. 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 qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to qux or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + 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 offset. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + optional int32 end = 4; + } +} diff --git a/proto-lens.cabal b/proto-lens.cabal --- a/proto-lens.cabal +++ b/proto-lens.cabal @@ -1,45 +1,72 @@ -name: proto-lens -version: 0.2.2.0 -synopsis: A lens-based implementation of protocol buffers in Haskell. -description: - The proto-lens library provides to protocol buffers using modern - Haskell language and library patterns. Specifically, it provides: - . - * Composable field accessors via lenses - . - * Simple field name resolution/overloading via type-level literals - . - * Type-safe reflection and encoding/decoding of messages via GADTs +-- This file has been generated from package.yaml by hpack version 0.20.0. +-- +-- see: https://github.com/sol/hpack +-- +-- hash: f4741b76c0ffaab3c07146f386e2d9d450fa3c819af4f8631f11b4abf8f1feb4 -homepage: https://github.com/google/proto-lens -license: BSD3 -license-file: LICENSE -author: Judah Jacobson -maintainer: proto-lens@googlegroups.com -copyright: Google Inc. -category: Data -build-type: Simple -cabal-version: >=1.8 -extra-source-files: Changelog.md +name: proto-lens +version: 0.3.0.0 +synopsis: A lens-based implementation of protocol buffers in Haskell. +description: The proto-lens library provides to protocol buffers using modern Haskell language and library patterns. Specifically, it provides: + . + * Composable field accessors via lenses + . + * Simple field name resolution/overloading via type-level literals + . + * Type-safe reflection and encoding/decoding of messages via GADTs +category: Data +homepage: https://github.com/google/proto-lens#readme +bug-reports: https://github.com/google/proto-lens/issues +author: Judah Jacobson +maintainer: proto-lens@googlegroups.com +copyright: Google Inc. +license: BSD3 +license-file: LICENSE +build-type: Simple +cabal-version: >= 1.10 +extra-source-files: + Changelog.md + +data-files: + proto-lens-imports/google/protobuf/compiler/plugin.proto + proto-lens-imports/google/protobuf/descriptor.proto + +source-repository head + type: git + location: https://github.com/google/proto-lens + subdir: proto-lens + library - hs-source-dirs: src - exposed-modules: Data.ProtoLens - Data.ProtoLens.Encoding - Data.ProtoLens.Message - Data.ProtoLens.Message.Enum - Data.ProtoLens.TextFormat - other-modules: Data.ProtoLens.Encoding.Bytes - Data.ProtoLens.Encoding.Wire - Data.ProtoLens.TextFormat.Parser - build-depends: attoparsec == 0.13.* - , base >= 4.8 && < 4.11 - , bytestring == 0.10.* - , containers == 0.5.* - , data-default-class >= 0.0 && < 0.2 - , lens-family == 1.2.* - , parsec == 3.1.* - , pretty == 1.1.* - , text == 1.2.* - , transformers >= 0.4 && < 0.6 - , void == 0.7.* + hs-source-dirs: + src + build-depends: + attoparsec ==0.13.* + , base >=4.8 && <4.11 + , bytestring ==0.10.* + , containers ==0.5.* + , data-default-class >=0.0 && <0.2 + , deepseq ==1.4.* + , lens-family ==1.2.* + , lens-labels ==0.2.* + , parsec ==3.1.* + , pretty ==1.1.* + , text ==1.2.* + , transformers >=0.4 && <0.6 + , void ==0.7.* + exposed-modules: + Data.ProtoLens + Data.ProtoLens.Encoding + Data.ProtoLens.Encoding.Wire + Data.ProtoLens.Message + Data.ProtoLens.Message.Enum + Data.ProtoLens.Service.Types + Data.ProtoLens.TextFormat + Proto.Google.Protobuf.Compiler.Plugin + Proto.Google.Protobuf.Compiler.Plugin_Fields + Proto.Google.Protobuf.Descriptor + Proto.Google.Protobuf.Descriptor_Fields + other-modules: + Data.ProtoLens.Encoding.Bytes + Data.ProtoLens.TextFormat.Parser + default-language: Haskell2010 diff --git a/src/Data/ProtoLens/Encoding.hs b/src/Data/ProtoLens/Encoding.hs --- a/src/Data/ProtoLens/Encoding.hs +++ b/src/Data/ProtoLens/Encoding.hs @@ -12,10 +12,12 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternGuards #-} +{-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.ProtoLens.Encoding( encodeMessage, buildMessage, + buildMessageDelimited, decodeMessage, decodeMessageOrDie, ) where @@ -28,13 +30,14 @@ import Control.Monad (guard) import Data.Attoparsec.ByteString as Parse import Data.Bool (bool) +import Data.Monoid ((<>)) import Data.Text.Encoding (encodeUtf8, decodeUtf8') import Data.Text.Encoding.Error (UnicodeException(..)) import qualified Data.ByteString as B import qualified Data.Map.Strict as Map import Data.ByteString.Lazy.Builder as Builder import qualified Data.ByteString.Lazy as L -import Lens.Family2 (set, over, (^.), (&)) +import Lens.Family2 (Lens', set, over, (^.), (&)) -- TODO: We could be more incremental when parsing/encoding length-based fields, -- rather than forcing the whole thing. E.g., for encoding we're doing extra @@ -51,23 +54,26 @@ parseMessage end = do (msg, unsetFields) <- loop def requiredFields if Map.null unsetFields - then return $ reverseRepeatedFields fields msg + then return $ over unknownFields reverse + $ reverseRepeatedFields fields msg else fail $ "Missing required fields " ++ show (map fieldDescriptorName $ Map.elems $ unsetFields) where - fields = fieldsByTag descriptor + fields = fieldsByTag + addUnknown :: TaggedValue -> msg -> msg + addUnknown !f = over' unknownFields (f :) requiredFields = Map.filter isRequired fields loop :: msg -> Map.Map Tag (FieldDescriptor msg) -> Parser (msg, Map.Map Tag (FieldDescriptor msg)) loop msg unsetFields = ((msg, unsetFields) <$ end) <|> do tv@(TaggedValue tag _) <- getTaggedValue - case Map.lookup (Tag tag) fields of - Nothing -> loop msg unsetFields + case Map.lookup tag fields of + Nothing -> (loop $! addUnknown tv msg) unsetFields Just field -> do !msg' <- parseAndAddField msg field tv - loop msg' $! Map.delete (Tag tag) unsetFields + loop msg' $! Map.delete tag unsetFields -- | Decode a message from its wire format. Throws an error if the decoding -- fails. @@ -87,23 +93,28 @@ !msg (FieldDescriptor name typeDescriptor accessor) (TaggedValue tag (WireValue wt val)) = let - getSimpleVal = case fieldWireType typeDescriptor of - GroupFieldType -> do + getSimpleVal = case typeDescriptor of + MessageField GroupType -> do Equal <- equalWireTypes name StartGroup wt parseMessage (endOfGroup name tag) - FieldWireType fieldWt _ get -> do - Equal <- equalWireTypes name fieldWt wt - runEither $ get val + MessageField MessageType -> do + Equal <- equalWireTypes name Lengthy wt + runEither $ decodeMessage val + ScalarField f -> case fieldWireType f of + FieldWireType fieldWt _ get -> do + Equal <- equalWireTypes name fieldWt wt + runEither $ get val -- Get a block of packed values, reversed. - getPackedVals = case fieldWireType typeDescriptor of - GroupFieldType -> fail "Groups can't be packed" - FieldWireType fieldWt _ get -> do - Equal <- equalWireTypes name Lengthy wt - let getElt = do - wv <- getWireValue fieldWt tag - x <- runEither $ get wv - return $! x - runEither $ parseOnly (manyReversedTill getElt endOfInput) val + getPackedVals = case typeDescriptor of + MessageField _ -> fail "Messages can't be packed" + ScalarField f -> case fieldWireType f of + FieldWireType fieldWt _ get -> do + Equal <- equalWireTypes name Lengthy wt + let getElt = do + wv <- getWireValue fieldWt + x <- runEither $ get wv + return $! x + runEither $ parseOnly (manyReversedTill getElt endOfInput) val in case accessor of PlainField _ f -> do !x <- getSimpleVal @@ -118,12 +129,12 @@ RepeatedField _ f -> (do !x <- getSimpleVal - return $! over f (\(!xs) -> x:xs) msg) - <|> (do + return $! over' f (x :) msg) + <|> (do xs <- getPackedVals - return $! over f (\(!ys) -> xs++ys) msg) + return $! over' f (xs ++) msg) <|> fail ("Field " ++ name - ++ "expects a repeated field wire type but found " + ++ " expects a repeated field wire type but found " ++ show wt) MapField keyLens valueLens f -> do entry <- getSimpleVal @@ -133,6 +144,15 @@ (Map.insert key value) msg +-- | Strict version of 'over' that forces the old value. +-- Helps prevent gross space leaks when modifying a list field. +-- +-- In particular, a naive `@over f (x :) y@ keeps the old value of @y@ around +-- in a thunk, because @(:)@ isn't strict in its second argument. (Similarly +-- for @(++)@.) +over' :: Lens' a b -> (b -> b) -> a -> a +over' f g = over f (\(!x) -> g x) + -- | Run the parser zero or more times, until the "end" parser succeeds. -- Returns a list of the parsed elements, in reverse order. manyReversedTill :: Parser a -> Parser b -> Parser [a] @@ -146,34 +166,50 @@ -- | Encode a message to the wire format, as part of a 'Builder'. buildMessage :: Message msg => msg -> Builder -buildMessage msg = foldMap putTaggedValue (messageToTaggedValues msg) +buildMessage = foldMap putTaggedValue . messageToTaggedValues +-- | Encode a message to the wire format, prefixed by its size as a VarInt, +-- as part of a 'Builder'. +-- +-- This can be used to build up streams of messages in the size-delimited +-- format expected by some protocols. +buildMessageDelimited :: Message msg => msg -> Builder +buildMessageDelimited msg = + let b = L.toStrict . toLazyByteString $ buildMessage msg in + putVarInt (fromIntegral $ B.length b) <> byteString b + -- | Encode a message as a sequence of key-value pairs. messageToTaggedValues :: Message msg => msg -> [TaggedValue] -messageToTaggedValues msg = mconcat - [ messageFieldToVals t fieldDescr msg - | (Tag t, fieldDescr) <- Map.toList (fieldsByTag descriptor) - ] +messageToTaggedValues msg = + mconcat + [ messageFieldToVals tag fieldDescr msg + | (tag, fieldDescr) <- Map.toList fieldsByTag + ] + ++ msg ^. unknownFields -messageFieldToVals :: Int -> FieldDescriptor a -> a -> [TaggedValue] +messageFieldToVals :: Tag -> FieldDescriptor a -> a -> [TaggedValue] messageFieldToVals tag (FieldDescriptor _ typeDescriptor accessor) msg = let embed src - = case fieldWireType typeDescriptor of - FieldWireType wt convert _ - -> [TaggedValue tag $ WireValue wt (convert src)] - GroupFieldType - -> TaggedValue tag (WireValue StartGroup ()) + = case typeDescriptor of + MessageField MessageType -> [TaggedValue tag $ WireValue Lengthy + $ encodeMessage src] + MessageField GroupType -> + TaggedValue tag (WireValue StartGroup ()) : messageToTaggedValues src ++ [TaggedValue tag $ WireValue EndGroup ()] + ScalarField f -> case fieldWireType f of + FieldWireType wt convert _ -> + [TaggedValue tag $ WireValue wt (convert src)] embedPacked [] = [] embedPacked src - = case fieldWireType typeDescriptor of - GroupFieldType -> error "GroupFieldType can't be packed" - FieldWireType wt convert _ -> let - v = L.toStrict $ toLazyByteString - $ mconcat [putWireValue wt (convert x) | x <- src] - in [TaggedValue tag $ WireValue Lengthy v] + = case typeDescriptor of + MessageField _ -> error "Messages can't be packed" + ScalarField f -> case fieldWireType f of + FieldWireType wt convert _ -> let + v = L.toStrict $ toLazyByteString + $ mconcat [putWireValue wt (convert x) | x <- src] + in [TaggedValue tag $ WireValue Lengthy v] in case accessor of PlainField d f -- proto3 optional scalar field: @@ -194,9 +230,8 @@ data FieldWireType value where FieldWireType :: WireType w -> (value -> w) -> (w -> Either String value) -> FieldWireType value - GroupFieldType :: Message value => FieldWireType value -fieldWireType :: FieldTypeDescriptor value -> FieldWireType value +fieldWireType :: ScalarField value -> FieldWireType value -- TODO: Don't let toEnum crash on unknown enum values. fieldWireType EnumField = simpleFieldWireType VarInt (fromIntegral . fromEnum) @@ -223,11 +258,8 @@ fieldWireType StringField = FieldWireType Lengthy encodeUtf8 (stringizeError . decodeUtf8') fieldWireType BytesField = identityFieldWireType Lengthy -fieldWireType MessageField = FieldWireType Lengthy encodeMessage - decodeMessage -fieldWireType GroupField = GroupFieldType -endOfGroup :: String -> Int -> Parser () +endOfGroup :: String -> Tag -> Parser () endOfGroup name tag = do TaggedValue tag' (WireValue wt _) <- getTaggedValue Equal <- equalWireTypes name EndGroup wt diff --git a/src/Data/ProtoLens/Encoding/Wire.hs b/src/Data/ProtoLens/Encoding/Wire.hs --- a/src/Data/ProtoLens/Encoding/Wire.hs +++ b/src/Data/ProtoLens/Encoding/Wire.hs @@ -5,6 +5,9 @@ -- https://developers.google.com/open-source/licenses/bsd {-# LANGUAGE GADTs #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternGuards #-} +{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RankNTypes #-} -- | Module defining the individual base wire types (e.g. VarInt, Fixed64) and -- how to encode/decode them. @@ -12,6 +15,7 @@ WireType(..), SomeWireType(..), WireValue(..), + Tag(..), TaggedValue(..), getTaggedValue, putTaggedValue, @@ -19,8 +23,10 @@ putWireValue, Equal(..), equalWireTypes, + decodeFieldSet, ) where +import Control.DeepSeq (NFData(..)) import Data.Attoparsec.ByteString as Parse import Data.Bits import qualified Data.ByteString as B @@ -31,6 +37,9 @@ import Data.ProtoLens.Encoding.Bytes data WireType a where + -- Note: all of these types are fully strict (vs, say, + -- Data.ByteString.Lazy.ByteString). If that changes, we'll + -- need to update the NFData instance. VarInt :: WireType Word64 Fixed64 :: WireType Word64 Fixed32 :: WireType Word32 @@ -38,16 +47,42 @@ StartGroup :: WireType () EndGroup :: WireType () +instance Show (WireType a) where + show = show . wireTypeToInt + + -- A value read from the wire data WireValue = forall a . WireValue !(WireType a) !a + +instance Show WireValue where + show (WireValue VarInt x) = show x + show (WireValue Fixed64 x) = show x + show (WireValue Fixed32 x) = show x + show (WireValue Lengthy x) = show x + show (WireValue StartGroup x) = show x + show (WireValue EndGroup x) = show x + + -- The wire contents of a single key-value pair in a Message. -data TaggedValue = TaggedValue !Int !WireValue +data TaggedValue = TaggedValue !Tag !WireValue + deriving (Show, Eq, Ord) -instance Show (WireType a) where - show = show . wireTypeToInt +-- TaggedValue, WireValue and Tag are strict, so their NFData instances are +-- trivial: +instance NFData TaggedValue where + rnf = (`seq` ()) +instance NFData WireValue where + rnf = (`seq` ()) + +-- | A tag that identifies a particular field of the message when converting +-- to/from the wire format. +newtype Tag = Tag { unTag :: Int} + deriving (Show, Eq, Ord, Num, NFData) + data Equal a b where - Equal :: Equal a a + -- TODO: move Eq/Ord instance somewhere else? + Equal :: (Eq a, Ord a) => Equal a a -- Assert that two wire types are the same, or fail with a message about this -- field. @@ -64,14 +99,26 @@ = fail $ "Field " ++ name ++ " expects wire type " ++ show expected ++ " but found " ++ show actual -getWireValue :: WireType a -> Int -> Parser a -getWireValue VarInt _ = getVarInt -getWireValue Fixed64 _ = anyBits -getWireValue Fixed32 _ = anyBits -getWireValue Lengthy _ = getVarInt >>= Parse.take . fromIntegral -getWireValue StartGroup _ = return () -getWireValue EndGroup _ = return () +instance Eq WireValue where + WireValue t v == WireValue t' v' + | Just Equal <- equalWireTypes "" t t' + = v == v' + | otherwise = False +instance Ord WireValue where + WireValue t v `compare` WireValue t' v' + | Just Equal <- equalWireTypes "" t t' + = v `compare` v' + | otherwise = wireTypeToInt t `compare` wireTypeToInt t' + +getWireValue :: WireType a -> Parser a +getWireValue VarInt = getVarInt +getWireValue Fixed64 = anyBits +getWireValue Fixed32 = anyBits +getWireValue Lengthy = getVarInt >>= Parse.take . fromIntegral +getWireValue StartGroup = return () +getWireValue EndGroup = return () + putWireValue :: WireType a -> a -> Builder putWireValue VarInt n = putVarInt n putWireValue Fixed64 n = word64LE n @@ -100,11 +147,11 @@ intToWireType 5 = Right $ SomeWireType Fixed32 intToWireType n = Left $ "Unrecognized wire type " ++ show n -putTypeAndTag :: WireType a -> Int -> Builder -putTypeAndTag wt tag +putTypeAndTag :: WireType a -> Tag -> Builder +putTypeAndTag wt (Tag tag) = putVarInt $ wireTypeToInt wt .|. fromIntegral tag `shiftL` 3 -getTypeAndTag :: Parser (SomeWireType, Int) +getTypeAndTag :: Parser (SomeWireType, Tag) getTypeAndTag = do n <- getVarInt case intToWireType (n .&. 7) of @@ -114,9 +161,12 @@ getTaggedValue :: Parser TaggedValue getTaggedValue = do (SomeWireType wt, tag) <- getTypeAndTag - val <- getWireValue wt tag + val <- getWireValue wt return $ TaggedValue tag (WireValue wt val) putTaggedValue :: TaggedValue -> Builder putTaggedValue (TaggedValue tag (WireValue wt val)) = putTypeAndTag wt tag <> putWireValue wt val + +decodeFieldSet :: B.ByteString -> Either String [TaggedValue] +decodeFieldSet = parseOnly (manyTill getTaggedValue endOfInput) diff --git a/src/Data/ProtoLens/Message.hs b/src/Data/ProtoLens/Message.hs --- a/src/Data/ProtoLens/Message.hs +++ b/src/Data/ProtoLens/Message.hs @@ -6,14 +6,18 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternGuards #-} {-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE TypeApplications #-} -- | Datatypes for reflection of protocol buffer messages. module Data.ProtoLens.Message ( -- * Reflection of Messages Message(..), Tag(..), - MessageDescriptor(..), + allFields, FieldDescriptor(..), fieldDescriptorName, isRequired, @@ -21,15 +25,29 @@ WireDefault(..), Packing(..), FieldTypeDescriptor(..), + ScalarField(..), + MessageOrGroup(..), FieldDefault(..), MessageEnum(..), -- * Building protocol buffers Default(..), build, + -- * Proto registries + Registry, + register, + lookupRegistered, + SomeMessageType(..), + -- * Any messages + matchAnyMessage, + AnyMessageDescriptor(..), -- * Utilities for constructing protocol buffer lenses maybeLens, -- * Internal utilities for parsing protocol buffers reverseRepeatedFields, + -- * Unknown fields + FieldSet, + TaggedValue(..), + discardUnknownFields, ) where import qualified Data.ByteString as B @@ -38,37 +56,41 @@ import qualified Data.Map as Map import Data.Map (Map) import Data.Maybe (fromMaybe) +import Data.Proxy (Proxy(..)) import qualified Data.Text as T import Data.Word -import Lens.Family2 (Lens', over) +import Lens.Family2 (Lens', over, set) import Lens.Family2.Unchecked (lens) +import Data.ProtoLens.Encoding.Wire + ( Tag(..) + , TaggedValue(..) + ) + -- | Every protocol buffer is an instance of 'Message'. This class enables -- serialization by providing reflection of all of the fields that may be used -- by this type. class Default msg => Message msg where - descriptor :: MessageDescriptor msg - --- | The description of a particular protocol buffer message type. -data MessageDescriptor msg = MessageDescriptor - { messageName :: T.Text - -- ^ A unique identifier for this type, of the format - -- @"packagename.messagename"@. - , fieldsByTag :: Map Tag (FieldDescriptor msg) - -- ^ The fields of the proto, indexed by their (integer) tag. - , fieldsByTextFormatName :: Map String (FieldDescriptor msg) - -- ^ This map is keyed by the name of the field used for text format protos. - -- This is just the field name for every field except for group fields, - -- which use their Message type name in text protos instead of their - -- field name. For example, "optional group Foo" has the field name "foo" - -- but in this map it is stored with the key "Foo". - } + -- | A unique identifier for this type, of the format + -- @"packagename.messagename"@. + messageName :: Proxy msg -> T.Text + -- | The fields of the proto, indexed by their (integer) tag. + fieldsByTag :: Map Tag (FieldDescriptor msg) + -- | This map is keyed by the name of the field used for text format protos. + -- This is just the field name for every field except for group fields, + -- which use their Message type name in text protos instead of their + -- field name. For example, "optional group Foo" has the field name "foo" + -- but in this map it is stored with the key "Foo". + fieldsByTextFormatName :: Map String (FieldDescriptor msg) + fieldsByTextFormatName = + Map.fromList [(n, f) | f@(FieldDescriptor n _ _) <- allFields] + -- | Access the unknown fields of a Message. + unknownFields :: Lens' msg FieldSet --- | A tag that identifies a particular field of the message when converting --- to/from the wire format. -newtype Tag = Tag { unTag :: Int} - deriving (Show, Eq, Ord, Num) +allFields :: Message msg => [FieldDescriptor msg] +allFields = Map.elems fieldsByTag +type FieldSet = [TaggedValue] -- | A description of a specific field of a protocol buffer. -- @@ -157,33 +179,57 @@ -- | A description of the type of a given field value. data FieldTypeDescriptor value where - MessageField :: Message value => FieldTypeDescriptor value - GroupField :: Message value => FieldTypeDescriptor value - EnumField :: MessageEnum value => FieldTypeDescriptor value - Int32Field :: FieldTypeDescriptor Int32 - Int64Field :: FieldTypeDescriptor Int64 - UInt32Field :: FieldTypeDescriptor Word32 - UInt64Field :: FieldTypeDescriptor Word64 - SInt32Field :: FieldTypeDescriptor Int32 - SInt64Field :: FieldTypeDescriptor Int64 - Fixed32Field :: FieldTypeDescriptor Word32 - Fixed64Field :: FieldTypeDescriptor Word64 - SFixed32Field :: FieldTypeDescriptor Int32 - SFixed64Field :: FieldTypeDescriptor Int64 - FloatField :: FieldTypeDescriptor Float - DoubleField :: FieldTypeDescriptor Double - BoolField :: FieldTypeDescriptor Bool - StringField :: FieldTypeDescriptor T.Text - BytesField :: FieldTypeDescriptor B.ByteString + MessageField :: Message value => MessageOrGroup -> FieldTypeDescriptor value + ScalarField :: ScalarField value -> FieldTypeDescriptor value deriving instance Show (FieldTypeDescriptor value) +data MessageOrGroup = MessageType | GroupType + deriving Show + +data ScalarField t where + EnumField :: MessageEnum value => ScalarField value + Int32Field :: ScalarField Int32 + Int64Field :: ScalarField Int64 + UInt32Field :: ScalarField Word32 + UInt64Field :: ScalarField Word64 + SInt32Field :: ScalarField Int32 + SInt64Field :: ScalarField Int64 + Fixed32Field :: ScalarField Word32 + Fixed64Field :: ScalarField Word64 + SFixed32Field :: ScalarField Int32 + SFixed64Field :: ScalarField Int64 + FloatField :: ScalarField Float + DoubleField :: ScalarField Double + BoolField :: ScalarField Bool + StringField :: ScalarField T.Text + BytesField :: ScalarField B.ByteString + +deriving instance Show (ScalarField value) + +matchAnyMessage :: forall value . FieldTypeDescriptor value -> Maybe (AnyMessageDescriptor value) +matchAnyMessage (MessageField _) + | messageName (Proxy @value) == "google.protobuf.Any" + , Just (FieldDescriptor _ (ScalarField StringField) (PlainField Optional typeUrlLens)) + <- Map.lookup 1 (fieldsByTag @value) + , Just (FieldDescriptor _ (ScalarField BytesField) (PlainField Optional valueLens)) + <- Map.lookup 2 (fieldsByTag @value) + = Just $ AnyMessageDescriptor typeUrlLens valueLens +matchAnyMessage _ = Nothing + +data AnyMessageDescriptor msg + = AnyMessageDescriptor + { anyTypeUrlLens :: Lens' msg T.Text + , anyValueLens :: Lens' msg B.ByteString + } + -- | A class for protocol buffer enums that enables safe decoding. class (Enum a, Bounded a) => MessageEnum a where -- | Convert the given 'Int' to an enum value. Returns 'Nothing' if -- no corresponding value was defined in the .proto file. maybeToEnum :: Int -> Maybe a - -- | Get the name of this enum as defined in the .proto file. + -- | Get the name of this enum as defined in the .proto file. Used + -- for the human-readable output in @Data.ProtoLens.TextFormat@. showEnum :: a -> String -- | Convert the given 'String' to an enum value. Returns 'Nothing' if -- no corresponding value was defined in the .proto file. @@ -231,3 +277,32 @@ reverseListField x (FieldDescriptor _ _ (RepeatedField _ f)) = over f reverse x reverseListField x _ = x + +-- | A set of known message types. Can help encode/decode protobufs containing +-- @Data.ProtoLens.Any@ values in a more human-readable text format. +-- +-- Registries can be combined using their 'Monoid' instance. +-- +-- See the @withRegistry@ functions in 'Data.ProtoLens.TextFormat' +newtype Registry = Registry (Map.Map T.Text SomeMessageType) + deriving Monoid + +-- | Build a 'Registry' containing a single proto type. +-- +-- Example: +-- > register (Proxy :: Proxy Proto.My.Proto.Type) +register :: forall msg . Message msg => Proxy msg -> Registry +register p = Registry $ Map.singleton (messageName (Proxy @msg)) (SomeMessageType p) + +-- | Look up a message type by name (e.g., +-- @"type.googleapis.com/google.protobuf.FloatValue"@). The URL corresponds to +-- the field @google.protobuf.Any.type_url@. +lookupRegistered :: T.Text -> Registry -> Maybe SomeMessageType +lookupRegistered n (Registry m) = Map.lookup (snd $ T.breakOnEnd "/" n) m + +data SomeMessageType where + SomeMessageType :: Message msg => Proxy msg -> SomeMessageType + +-- TODO: recursively +discardUnknownFields :: Message msg => msg -> msg +discardUnknownFields = set unknownFields [] diff --git a/src/Data/ProtoLens/Service/Types.hs b/src/Data/ProtoLens/Service/Types.hs new file mode 100644 --- /dev/null +++ b/src/Data/ProtoLens/Service/Types.hs @@ -0,0 +1,126 @@ +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} + +-- | This module provides typeclasses for describing protobuf service metadata. +-- It is intended to be used by library authors to generating bindings against +-- proto services for specific RPC backends. +module Data.ProtoLens.Service.Types + ( Service (..) + , HasAllMethods + , HasMethodImpl (..) + , HasMethod + , StreamingType (..) + ) where + +import Data.Kind (Constraint) +import Data.ProtoLens.Message (Message) +import GHC.TypeLits + + +-- | Reifies the fact that there is a 'HasMethod' instance for every symbol +-- claimed by the 'ServiceMethods' associated type. +class HasAllMethods s (ms :: [Symbol]) +instance HasAllMethods s '[] +instance (HasAllMethods s ms, HasMethodImpl s m) => HasAllMethods s (m ': ms) + + +-- | Metadata describing a protobuf service. The 's' parameter is a phantom +-- type generated by proto-lens. +-- +-- The 'ServiceName' and 'ServicePackage' associated type can be used to +-- generate RPC endpoint paths. +-- +-- 'ServiceMethods' is a promoted list containing every method defined on the +-- service. As witnessed by the 'HasAllMethods' superclass constraint here, +-- this type can be used to discover every instance of 'HasMethod' available +-- for the service. +class ( KnownSymbol (ServiceName s) + , KnownSymbol (ServicePackage s) + , HasAllMethods s (ServiceMethods s) + ) => Service s where + type ServiceName s :: Symbol + type ServicePackage s :: Symbol + type ServiceMethods s :: [Symbol] + + +------------------------------------------------------------------------------ +-- | Data type to be used as a promoted type for 'MethodStreamingType'. +data StreamingType + = NonStreaming + | ClientStreaming + | ServerStreaming + | BiDiStreaming + deriving (Eq, Ord, Enum, Bounded, Read, Show) + + +-- | Metadata describing a service method. The 'MethodInput' and 'MethodOutput' +-- type families correspond to the 'Message's generated by proto-lens for the +-- RPC as described in the protobuf. +-- +-- 'IsClientStreaming' and 'IsServerStreaming' can be used to dispatch on +-- library code which wishes to provide different interfaces depending on the +-- type of streaming of the method. +-- +-- Library code should use 'HasMethod' instead of this class directly whenever +-- the constraint will be exposed to the end user. 'HasMethod' provides +-- substantially friendlier error messages when used incorrectly. +class ( KnownSymbol m + , KnownSymbol (MethodName s m) + , Service s + , Message (MethodInput s m) + , Message (MethodOutput s m) + ) => HasMethodImpl s (m :: Symbol) where + type MethodName s m :: Symbol + type MethodInput s m :: * + type MethodOutput s m :: * + type MethodStreamingType s m :: StreamingType + + +-- | Helper constraint that expands to a user-friendly error message when 'm' +-- isn't actually a method provided by service 's'. +type HasMethod s m = + ( RequireHasMethod s m (ListContains m (ServiceMethods s)) + , HasMethodImpl s m + ) + + +-- | Outputs an error message saying that the given method wasn't found, and +-- suggests alternatives the user might have wanted. +type family RequireHasMethod s (m :: Symbol) (h :: Bool) :: Constraint where + RequireHasMethod s m 'False = TypeError + ( 'Text "No method " + ':<>: 'ShowType m + ':<>: 'Text " available for service '" + ':<>: 'ShowType s + ':<>: 'Text "'." + ':$$: 'Text "Available methods are: " + ':<>: ShowList (ServiceMethods s) + ) + RequireHasMethod s m 'True = () + + +-- | Expands to 'True' when 'n' is in promoted list 'hs', 'False' otherwise. +type family ListContains (n :: k) (hs :: [k]) :: Bool where + ListContains n '[] = 'False + ListContains n (n ': hs) = 'True + ListContains n (x ': hs) = ListContains n hs + + +-- | Pretty prints a promoted list. +type family ShowList (ls :: [k]) :: ErrorMessage where + ShowList '[] = 'Text "" + ShowList '[x] = 'ShowType x + ShowList (x ': xs) = + 'ShowType x ':<>: 'Text ", " ':<>: ShowList xs + diff --git a/src/Data/ProtoLens/TextFormat.hs b/src/Data/ProtoLens/TextFormat.hs --- a/src/Data/ProtoLens/TextFormat.hs +++ b/src/Data/ProtoLens/TextFormat.hs @@ -6,31 +6,41 @@ -- | Functions for converting protocol buffers to a human-readable text format. {-# LANGUAGE GADTs #-} +{-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} module Data.ProtoLens.TextFormat( showMessage, + showMessageWithRegistry, showMessageShort, pprintMessage, + pprintMessageWithRegistry, readMessage, + readMessageWithRegistry, readMessageOrDie, ) where -import Lens.Family2 ((&),(^.),(.~), set, over) +import Lens.Family2 ((&),(^.),(.~), set, over, view) import Control.Arrow (left) +import Data.Bifunctor (first) import qualified Data.ByteString import Data.Char (isPrint, isAscii, chr) import Data.Foldable (foldlM, foldl') -import Data.Maybe (catMaybes) import qualified Data.Map as Map +import Data.Maybe (catMaybes) +import Data.Proxy (Proxy(Proxy)) +import Data.ProtoLens.Encoding (encodeMessage, decodeMessage) import qualified Data.Set as Set import qualified Data.Text.Encoding as Text import qualified Data.Text.Lazy as Lazy +import qualified Data.Text as Text (unpack) import Numeric (showOct) import Text.Parsec (parse) import Text.PrettyPrint +import Data.ProtoLens.Encoding.Wire import Data.ProtoLens.Message import qualified Data.ProtoLens.TextFormat.Parser as Parser @@ -52,28 +62,36 @@ -- | Pretty-print the given message into a human-readable form. pprintMessage :: Message msg => msg -> Doc -pprintMessage = pprintMessage' descriptor +pprintMessage = pprintMessageWithRegistry mempty +-- | Pretty-print the given message into human-readable form, using the given +-- 'Registry' to decode @google.protobuf.Any@ values. +pprintMessageWithRegistry :: Message msg => Registry -> msg -> Doc +pprintMessageWithRegistry reg msg + -- Either put all fields together on a single line, or use a separate line + -- for each field. We use a single "sep" for all fields (and all elements + -- of all the repeated fields) to avoid putting some repeated fields on one + -- line and other fields on multiple lines, which is less readable. + = sep $ concatMap (pprintField reg msg) allFields + ++ map pprintTaggedValue (msg ^. unknownFields) + -- | Convert the given message into a human-readable 'String'. showMessage :: Message msg => msg -> String showMessage = render . pprintMessage +-- | Convert the given message into a human-readable 'String', using the +-- 'Registry' to encode @google.protobuf.Any@ values. +showMessageWithRegistry :: Message msg => Registry -> msg -> String +showMessageWithRegistry reg = render . pprintMessageWithRegistry reg + -- | Serializes a proto as a string on a single line. Useful for debugging -- and error messages like @.DebugString()@ in other languages. showMessageShort :: Message msg => msg -> String showMessageShort = renderStyle (Style OneLineMode maxBound 1.5) . pprintMessage -pprintMessage' :: MessageDescriptor msg -> msg -> Doc -pprintMessage' descr msg - -- Either put all fields together on a single line, or use a separate line - -- for each field. We use a single "sep" for all fields (and all elements - -- of all the repeated fields) to avoid putting some repeated fields on one - -- line and other fields on multiple lines, which is less readable. - = sep $ concatMap (pprintField msg) $ Map.elems $ fieldsByTag descr - -pprintField :: msg -> FieldDescriptor msg -> [Doc] -pprintField msg (FieldDescriptor name typeDescr accessor) - = map (pprintFieldValue name typeDescr) $ case accessor of +pprintField :: Registry -> msg -> FieldDescriptor msg -> [Doc] +pprintField reg msg (FieldDescriptor name typeDescr accessor) + = map (pprintFieldValue reg name typeDescr) $ case accessor of PlainField d f | Optional <- d, val == fieldDefault -> [] | otherwise -> [val] @@ -85,28 +103,50 @@ where pairToMsg (x,y) = def & k .~ x & v .~ y -pprintFieldValue :: String -> FieldTypeDescriptor value -> value -> Doc -pprintFieldValue name MessageField m - = sep [text name <+> lbrace, nest 2 (pprintMessage m), rbrace] -pprintFieldValue name EnumField x = text name <> colon <+> text (showEnum x) -pprintFieldValue name Int32Field x = primField name x -pprintFieldValue name Int64Field x = primField name x -pprintFieldValue name UInt32Field x = primField name x -pprintFieldValue name UInt64Field x = primField name x -pprintFieldValue name SInt32Field x = primField name x -pprintFieldValue name SInt64Field x = primField name x -pprintFieldValue name Fixed32Field x = primField name x -pprintFieldValue name Fixed64Field x = primField name x -pprintFieldValue name SFixed32Field x = primField name x -pprintFieldValue name SFixed64Field x = primField name x -pprintFieldValue name FloatField x = primField name x -pprintFieldValue name DoubleField x = primField name x -pprintFieldValue name BoolField x = text name <> colon <+> boolValue x -pprintFieldValue name StringField x = pprintByteString name (Text.encodeUtf8 x) -pprintFieldValue name BytesField x = pprintByteString name x -pprintFieldValue name GroupField m - = text name <+> lbrace $$ nest 2 (pprintMessage m) $$ rbrace +pprintFieldValue :: Registry -> String -> FieldTypeDescriptor value -> value -> Doc +pprintFieldValue reg name field@(MessageField MessageType) m + | Just AnyMessageDescriptor { anyTypeUrlLens, anyValueLens } <- matchAnyMessage field, + typeUri <- view anyTypeUrlLens m, + fieldData <- view anyValueLens m, + Just (SomeMessageType (Proxy :: Proxy value')) <- lookupRegistered typeUri reg, + Right (anyValue :: value') <- decodeMessage fieldData = + pprintSubmessage name + $ sep + [ lbrack <> text (Text.unpack typeUri) <> rbrack <+> lbrace + , nest 2 (pprintMessageWithRegistry reg anyValue) + , rbrace ] + | otherwise = + pprintSubmessage name (pprintMessageWithRegistry reg m) +pprintFieldValue reg name (MessageField GroupType) m + = pprintSubmessage name (pprintMessageWithRegistry reg m) +pprintFieldValue _ name (ScalarField f) x = named name $ pprintScalarValue f x +named :: String -> Doc -> Doc +named n x = text n <> colon <+> x + + +pprintScalarValue :: ScalarField value -> value -> Doc +pprintScalarValue EnumField x = text (showEnum x) +pprintScalarValue Int32Field x = primField x +pprintScalarValue Int64Field x = primField x +pprintScalarValue UInt32Field x = primField x +pprintScalarValue UInt64Field x = primField x +pprintScalarValue SInt32Field x = primField x +pprintScalarValue SInt64Field x = primField x +pprintScalarValue Fixed32Field x = primField x +pprintScalarValue Fixed64Field x = primField x +pprintScalarValue SFixed32Field x = primField x +pprintScalarValue SFixed64Field x = primField x +pprintScalarValue FloatField x = primField x +pprintScalarValue DoubleField x = primField x +pprintScalarValue BoolField x = boolValue x +pprintScalarValue StringField x = pprintByteString (Text.encodeUtf8 x) +pprintScalarValue BytesField x = pprintByteString x + +pprintSubmessage :: String -> Doc -> Doc +pprintSubmessage name contents = + sep [text name <+> lbrace, nest 2 contents, rbrace] + -- | Formats a string in a way that mostly matches the C-compatible escaping -- used by the Protocol Buffer distribution. We depart a bit by escaping all -- non-ASCII characters, which depending on the locale, the distribution might @@ -116,8 +156,8 @@ -- and \\ only. Note that Haskell string-literal syntax calls for "\011" to be -- interpreted as decimal 11, rather than the decimal 9 it actually represent, -- so you can't use Prelude.read to parse the strings created here. -pprintByteString :: String -> Data.ByteString.ByteString -> Doc -pprintByteString name x = text name <> colon <+> char '\"' +pprintByteString :: Data.ByteString.ByteString -> Doc +pprintByteString x = char '\"' <> text (concatMap escape $ Data.ByteString.unpack x) <> char '\"' where escape w8 | ch == '\n' = "\\n" | ch == '\r' = "\\r" @@ -131,19 +171,34 @@ ch = chr $ fromIntegral w8 pad str = replicate (3 - length str) '0' ++ str -primField :: Show value => String -> value -> Doc -primField name x = text name <> colon <+> text (show x) +primField :: Show value => value -> Doc +primField x = text (show x) boolValue :: Bool -> Doc boolValue True = text "true" boolValue False = text "false" +pprintTaggedValue :: TaggedValue -> Doc +pprintTaggedValue (TaggedValue t (WireValue v x)) = case v of + VarInt -> named name $ primField x + Fixed64 -> named name $ primField x + Fixed32 -> named name $ primField x + Lengthy -> case decodeFieldSet x of + Left _ -> named name $ pprintByteString x + Right ts -> pprintSubmessage name + $ sep $ map pprintTaggedValue ts + -- TODO: implement better printing for unknown groups + StartGroup -> named name $ text "start_group" + EndGroup -> named name $ text "end_group" + where + name = show (unTag t) + -------------------------------------------------------------------------------- -- Parsing -- | Parse a 'Message' from the human-readable protocol buffer text format. readMessage :: Message msg => Lazy.Text -> Either String msg -readMessage str = left show (parse Parser.parser "" str) >>= buildMessage +readMessage = readMessageWithRegistry mempty -- | Parse a 'Message' from the human-readable protocol buffer text format. -- Throws an error if the parse was not successful. @@ -152,47 +207,49 @@ Left e -> error $ "readMessageOrDie: " ++ e Right x -> x -buildMessage :: forall msg . Message msg => Parser.Message -> Either String msg -buildMessage fields - | missing <- missingFields desc fields, not $ null missing +-- | Parse a 'Message' from a human-readable protocol buffer text format, using +-- the given 'Registry' to decode 'Any' fields +readMessageWithRegistry :: Message msg => Registry -> Lazy.Text -> Either String msg +readMessageWithRegistry reg str = left show (parse Parser.parser "" str) >>= buildMessage reg + +buildMessage :: forall msg . Message msg => Registry -> Parser.Message -> Either String msg +buildMessage reg fields + | missing <- missingFields (Proxy @msg) fields, not $ null missing = Left $ "Missing fields " ++ show missing - | otherwise = reverseRepeatedFields (fieldsByTag desc) - <$> buildMessageFromDescriptor desc def fields - where - desc :: MessageDescriptor msg - desc = descriptor + | otherwise = reverseRepeatedFields fieldsByTag + <$> buildMessageFromDescriptor reg def fields -missingFields :: MessageDescriptor msg -> Parser.Message -> [String] -missingFields desc = Set.toList . foldl' deleteField requiredFieldNames +missingFields :: forall msg . Message msg => Proxy msg -> Parser.Message -> [String] +missingFields _ = Set.toList . foldl' deleteField requiredFieldNames where requiredFieldNames :: Set.Set String requiredFieldNames = Set.fromList $ Map.keys $ Map.filter isRequired - $ fieldsByTextFormatName desc + $ fieldsByTextFormatName @msg deleteField :: Set.Set String -> Parser.Field -> Set.Set String deleteField fs (Parser.Field (Parser.Key name) _) = Set.delete name fs deleteField fs (Parser.Field (Parser.UnknownKey n) _) - | Just d <- Map.lookup (Tag (fromIntegral n)) $ fieldsByTag desc + | Just d <- Map.lookup (Tag (fromIntegral n)) (fieldsByTag @msg) = Set.delete (fieldDescriptorName d) fs deleteField fs _ = fs buildMessageFromDescriptor - :: MessageDescriptor msg -> msg -> Parser.Message -> Either String msg -buildMessageFromDescriptor descr = foldlM (addField descr) + :: Message msg => Registry -> msg -> Parser.Message -> Either String msg +buildMessageFromDescriptor reg = foldlM (addField reg) -addField :: MessageDescriptor msg -> msg -> Parser.Field -> Either String msg -addField descr msg (Parser.Field key rawValue) = do - FieldDescriptor _ typeDescriptor accessor <- getFieldDescriptor - value <- makeValue typeDescriptor rawValue +addField :: forall msg . Message msg => Registry -> msg -> Parser.Field -> Either String msg +addField reg msg (Parser.Field key rawValue) = do + FieldDescriptor name typeDescriptor accessor <- getFieldDescriptor + value <- makeValue name reg typeDescriptor rawValue return $ modifyField accessor value msg where getFieldDescriptor | Parser.Key name <- key, Just f <- Map.lookup name - (fieldsByTextFormatName descr) + fieldsByTextFormatName = return f | Parser.UnknownKey tag <- key, Just f <- Map.lookup (fromIntegral tag) - (fieldsByTag descr) + fieldsByTag = return f | otherwise = Left $ "Unrecognized field " ++ show key @@ -203,37 +260,63 @@ modifyField (MapField key value f) mapElem = over f (Map.insert (mapElem ^. key) (mapElem ^. value)) -makeValue :: FieldTypeDescriptor value -> Parser.Value -> Either String value -makeValue Int32Field (Parser.IntValue x) = Right (fromInteger x) -makeValue Int64Field (Parser.IntValue x) = Right (fromInteger x) -makeValue UInt32Field (Parser.IntValue x) = Right (fromInteger x) -makeValue UInt64Field (Parser.IntValue x) = Right (fromInteger x) -makeValue SInt32Field (Parser.IntValue x) = Right (fromInteger x) -makeValue SInt64Field (Parser.IntValue x) = Right (fromInteger x) -makeValue Fixed32Field (Parser.IntValue x) = Right (fromInteger x) -makeValue Fixed64Field (Parser.IntValue x) = Right (fromInteger x) -makeValue SFixed32Field (Parser.IntValue x) = Right (fromInteger x) -makeValue SFixed64Field (Parser.IntValue x) = Right (fromInteger x) -makeValue FloatField (Parser.IntValue x) = Right (fromInteger x) -makeValue DoubleField (Parser.IntValue x) = Right (fromInteger x) -makeValue BoolField (Parser.IntValue x) +makeValue + :: forall value + . String -- ^ name of field + -> Registry + -> FieldTypeDescriptor value + -> Parser.Value + -> Either String value +makeValue name _ (ScalarField f) v = + first (("Error parsing field " ++ show name ++ ": ") ++) $ makeScalarValue f v +makeValue name reg field@(MessageField MessageType) (Parser.MessageValue (Just typeUri) x) + | Just AnyMessageDescriptor { anyTypeUrlLens, anyValueLens } <- matchAnyMessage field = + case lookupRegistered typeUri reg of + Nothing -> Left $ "Could not decode google.protobuf.Any for field " + ++ show name ++ ": unregistered type URI " + ++ show typeUri + Just (SomeMessageType (Proxy :: Proxy value')) -> + case buildMessage reg x :: Either String value' of + Left err -> Left err + Right value' -> Right (def & anyTypeUrlLens .~ typeUri + & anyValueLens .~ encodeMessage value') + | otherwise = Left ("Type mismatch parsing explicitly typed message. Expected " ++ + show (messageName (Proxy @value)) ++ + ", got " ++ show typeUri) +makeValue _ reg (MessageField _) (Parser.MessageValue _ x) = buildMessage reg x +makeValue name _ (MessageField _) val = + Left $ "Type mismatch for field " ++ show name ++ + ": expected message, found " ++ show val + +makeScalarValue :: ScalarField value -> Parser.Value -> Either String value +makeScalarValue Int32Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue Int64Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue UInt32Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue UInt64Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue SInt32Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue SInt64Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue Fixed32Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue Fixed64Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue SFixed32Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue SFixed64Field (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue FloatField (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue DoubleField (Parser.IntValue x) = Right (fromInteger x) +makeScalarValue BoolField (Parser.IntValue x) | x == 0 = Right False | x == 1 = Right True | otherwise = Left $ "Unrecognized bool value " ++ show x -makeValue DoubleField (Parser.DoubleValue x) = Right x -makeValue FloatField (Parser.DoubleValue x) = Right (realToFrac x) -makeValue BoolField (Parser.EnumValue x) +makeScalarValue DoubleField (Parser.DoubleValue x) = Right x +makeScalarValue FloatField (Parser.DoubleValue x) = Right (realToFrac x) +makeScalarValue BoolField (Parser.EnumValue x) | x == "true" = Right True | x == "false" = Right False | otherwise = Left $ "Unrecognized bool value " ++ show x -makeValue StringField (Parser.ByteStringValue x) = Right (Text.decodeUtf8 x) -makeValue BytesField (Parser.ByteStringValue x) = Right x -makeValue EnumField (Parser.IntValue x) = +makeScalarValue StringField (Parser.ByteStringValue x) = Right (Text.decodeUtf8 x) +makeScalarValue BytesField (Parser.ByteStringValue x) = Right x +makeScalarValue EnumField (Parser.IntValue x) = maybe (Left $ "Unrecognized enum value " ++ show x) Right (maybeToEnum $ fromInteger x) -makeValue EnumField (Parser.EnumValue x) = +makeScalarValue EnumField (Parser.EnumValue x) = maybe (Left $ "Unrecognized enum value " ++ show x) Right (readEnum x) -makeValue MessageField (Parser.MessageValue x) = buildMessage x -makeValue GroupField (Parser.MessageValue x) = buildMessage x -makeValue f val = Left $ "Type mismatch parsing text format: " ++ show (f, val) +makeScalarValue f val = Left $ "Type mismatch: " ++ show (f, val) diff --git a/src/Data/ProtoLens/TextFormat/Parser.hs b/src/Data/ProtoLens/TextFormat/Parser.hs --- a/src/Data/ProtoLens/TextFormat/Parser.hs +++ b/src/Data/ProtoLens/TextFormat/Parser.hs @@ -15,13 +15,15 @@ ) where import Data.ByteString (ByteString, pack) -import Data.Char (ord) +import Data.Char (ord, isSpace) import Data.Functor.Identity (Identity) import Data.List (intercalate) import Data.Maybe (catMaybes) import Data.Text.Lazy (Text) +import qualified Data.Text as StrictText import Data.Word (Word8) import Numeric (readOct, readHex) +import Text.Parsec (()) import Text.Parsec.Char (alphaNum, char, hexDigit, letter, octDigit, oneOf, satisfy) import Text.Parsec.Text.Lazy (Parser) @@ -67,13 +69,14 @@ data Value = IntValue Integer -- ^ An integer | DoubleValue Double -- ^ Any floating point number | ByteStringValue ByteString -- ^ A string or bytes literal - | MessageValue Message -- ^ A sub message + | MessageValue (Maybe StrictText.Text) Message -- ^ A sub message, with an optional type URI | EnumValue String -- ^ Any undelimited string (including false & true) deriving (Show,Ord,Eq) instance Show Key where - show (Key name) = name + show (Key name) = show name -- Quoting field names (i.e., `"field"` vs `field` + -- leads to nicer error messages. show (UnknownKey k) = show k show (ExtensionKey name) = "[" ++ intercalate "." name ++ "]" show (UnknownExtensionKey k) = "[" ++ show k ++ "]" @@ -100,8 +103,15 @@ parseString = liftM (ByteStringValue . mconcat) $ many1 $ lexeme ptp $ protoStringLiteral parseEnumValue = liftM EnumValue (identifier ptp) - parseMessageValue = liftM MessageValue - (braces ptp parseMessage <|> angles ptp parseMessage) + parseMessageValue = + braces ptp (parseAny <|> + liftM (MessageValue Nothing) parseMessage) <|> + angles ptp (liftM (MessageValue Nothing) parseMessage) + + typeUri = liftM StrictText.pack (many (satisfy (\c -> c /= ']' && not (isSpace c)))) + "type URI" + parseAny = liftM2 MessageValue (liftM Just (brackets ptp typeUri)) + (braces ptp parseMessage) makeNumberValue :: Bool -> Either Integer Double -> Value makeNumberValue True (Left intValue) = IntValue (negate intValue) diff --git a/src/Proto/Google/Protobuf/Compiler/Plugin.hs b/src/Proto/Google/Protobuf/Compiler/Plugin.hs new file mode 100644 --- /dev/null +++ b/src/Proto/Google/Protobuf/Compiler/Plugin.hs @@ -0,0 +1,345 @@ +{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, GeneralizedNewtypeDeriving, + MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, + PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports#-} +module Proto.Google.Protobuf.Compiler.Plugin + (CodeGeneratorRequest(..), CodeGeneratorResponse(..), + CodeGeneratorResponse'File(..)) + where +import qualified Lens.Labels.Prism +import qualified Prelude +import qualified Data.Int +import qualified Data.Word +import qualified Data.ProtoLens +import qualified Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Service.Types +import qualified Lens.Family2 +import qualified Lens.Family2.Unchecked +import qualified Data.Default.Class +import qualified Data.Text +import qualified Data.Map +import qualified Data.ByteString +import qualified Data.ByteString.Char8 +import qualified Lens.Labels +import qualified Text.Read +import qualified Proto.Google.Protobuf.Descriptor + +{- | Fields : + + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.fileToGenerate' @:: Lens' CodeGeneratorRequest [Data.Text.Text]@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.parameter' @:: Lens' CodeGeneratorRequest Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'parameter' @:: Lens' CodeGeneratorRequest (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.protoFile' @:: Lens' CodeGeneratorRequest + [Proto.Google.Protobuf.Descriptor.FileDescriptorProto]@ + -} +data CodeGeneratorRequest = CodeGeneratorRequest{_CodeGeneratorRequest'fileToGenerate + :: ![Data.Text.Text], + _CodeGeneratorRequest'parameter :: + !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorRequest'protoFile :: + ![Proto.Google.Protobuf.Descriptor.FileDescriptorProto], + _CodeGeneratorRequest'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f CodeGeneratorRequest x a, + a ~ b) => + Lens.Labels.HasLens f CodeGeneratorRequest CodeGeneratorRequest x a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorRequest "fileToGenerate" + ([Data.Text.Text]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'fileToGenerate + (\ x__ y__ -> x__{_CodeGeneratorRequest'fileToGenerate = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorRequest "parameter" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'parameter + (\ x__ y__ -> x__{_CodeGeneratorRequest'parameter = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorRequest "maybe'parameter" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'parameter + (\ x__ y__ -> x__{_CodeGeneratorRequest'parameter = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorRequest "protoFile" + ([Proto.Google.Protobuf.Descriptor.FileDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'protoFile + (\ x__ y__ -> x__{_CodeGeneratorRequest'protoFile = y__})) + Prelude.id +instance Data.Default.Class.Default CodeGeneratorRequest where + def + = CodeGeneratorRequest{_CodeGeneratorRequest'fileToGenerate = [], + _CodeGeneratorRequest'parameter = Prelude.Nothing, + _CodeGeneratorRequest'protoFile = [], + _CodeGeneratorRequest'_unknownFields = ([])} +instance Data.ProtoLens.Message CodeGeneratorRequest where + messageName _ + = Data.Text.pack "google.protobuf.compiler.CodeGeneratorRequest" + fieldsByTag + = let fileToGenerate__field_descriptor + = Data.ProtoLens.FieldDescriptor "file_to_generate" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fileToGenerate"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest + parameter__field_descriptor + = Data.ProtoLens.FieldDescriptor "parameter" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'parameter"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest + protoFile__field_descriptor + = Data.ProtoLens.FieldDescriptor "proto_file" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor + Proto.Google.Protobuf.Descriptor.FileDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "protoFile"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, fileToGenerate__field_descriptor), + (Data.ProtoLens.Tag 2, parameter__field_descriptor), + (Data.ProtoLens.Tag 15, protoFile__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _CodeGeneratorRequest'_unknownFields + (\ x__ y__ -> x__{_CodeGeneratorRequest'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.error' @:: Lens' CodeGeneratorResponse Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'error' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.file' @:: Lens' CodeGeneratorResponse [CodeGeneratorResponse'File]@ + -} +data CodeGeneratorResponse = CodeGeneratorResponse{_CodeGeneratorResponse'error + :: !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorResponse'file :: + ![CodeGeneratorResponse'File], + _CodeGeneratorResponse'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f CodeGeneratorResponse x a, + a ~ b) => + Lens.Labels.HasLens f CodeGeneratorResponse CodeGeneratorResponse x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse "error" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'error + (\ x__ y__ -> x__{_CodeGeneratorResponse'error = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse "maybe'error" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'error + (\ x__ y__ -> x__{_CodeGeneratorResponse'error = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse "file" + ([CodeGeneratorResponse'File]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'file + (\ x__ y__ -> x__{_CodeGeneratorResponse'file = y__})) + Prelude.id +instance Data.Default.Class.Default CodeGeneratorResponse where + def + = CodeGeneratorResponse{_CodeGeneratorResponse'error = + Prelude.Nothing, + _CodeGeneratorResponse'file = [], + _CodeGeneratorResponse'_unknownFields = ([])} +instance Data.ProtoLens.Message CodeGeneratorResponse where + messageName _ + = Data.Text.pack "google.protobuf.compiler.CodeGeneratorResponse" + fieldsByTag + = let error__field_descriptor + = Data.ProtoLens.FieldDescriptor "error" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'error"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + file__field_descriptor + = Data.ProtoLens.FieldDescriptor "file" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor CodeGeneratorResponse'File) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, error__field_descriptor), + (Data.ProtoLens.Tag 15, file__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _CodeGeneratorResponse'_unknownFields + (\ x__ y__ -> x__{_CodeGeneratorResponse'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.name' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'name' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.insertionPoint' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'insertionPoint' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.content' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'content' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@ + -} +data CodeGeneratorResponse'File = CodeGeneratorResponse'File{_CodeGeneratorResponse'File'name + :: !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorResponse'File'insertionPoint + :: !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorResponse'File'content :: + !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorResponse'File'_unknownFields + :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f CodeGeneratorResponse'File x a, + a ~ b) => + Lens.Labels.HasLens f CodeGeneratorResponse'File + CodeGeneratorResponse'File + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File "name" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'name + (\ x__ y__ -> x__{_CodeGeneratorResponse'File'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'name + (\ x__ y__ -> x__{_CodeGeneratorResponse'File'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File "insertionPoint" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'insertionPoint + (\ x__ y__ -> + x__{_CodeGeneratorResponse'File'insertionPoint = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File + "maybe'insertionPoint" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'insertionPoint + (\ x__ y__ -> + x__{_CodeGeneratorResponse'File'insertionPoint = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File "content" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'content + (\ x__ y__ -> x__{_CodeGeneratorResponse'File'content = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f CodeGeneratorResponse'File "maybe'content" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'content + (\ x__ y__ -> x__{_CodeGeneratorResponse'File'content = y__})) + Prelude.id +instance Data.Default.Class.Default CodeGeneratorResponse'File + where + def + = CodeGeneratorResponse'File{_CodeGeneratorResponse'File'name = + Prelude.Nothing, + _CodeGeneratorResponse'File'insertionPoint = Prelude.Nothing, + _CodeGeneratorResponse'File'content = Prelude.Nothing, + _CodeGeneratorResponse'File'_unknownFields = ([])} +instance Data.ProtoLens.Message CodeGeneratorResponse'File where + messageName _ + = Data.Text.pack + "google.protobuf.compiler.CodeGeneratorResponse.File" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File + insertionPoint__field_descriptor + = Data.ProtoLens.FieldDescriptor "insertion_point" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'insertionPoint"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File + content__field_descriptor + = Data.ProtoLens.FieldDescriptor "content" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'content"))) + :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, insertionPoint__field_descriptor), + (Data.ProtoLens.Tag 15, content__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'_unknownFields + (\ x__ y__ -> + x__{_CodeGeneratorResponse'File'_unknownFields = y__}) diff --git a/src/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs b/src/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs new file mode 100644 --- /dev/null +++ b/src/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs @@ -0,0 +1,109 @@ +{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, GeneralizedNewtypeDeriving, + MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, + PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports#-} +module Proto.Google.Protobuf.Compiler.Plugin_Fields where +import qualified Prelude +import qualified Data.Int +import qualified Data.Word +import qualified Data.ProtoLens +import qualified Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Service.Types +import qualified Lens.Family2 +import qualified Lens.Family2.Unchecked +import qualified Data.Default.Class +import qualified Data.Text +import qualified Data.Map +import qualified Data.ByteString +import qualified Data.ByteString.Char8 +import qualified Lens.Labels +import qualified Text.Read +import qualified Proto.Google.Protobuf.Descriptor + +content :: + forall f s t a b . (Lens.Labels.HasLens f s t "content" a b) => + Lens.Family2.LensLike f s t a b +content + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "content") +error :: + forall f s t a b . (Lens.Labels.HasLens f s t "error" a b) => + Lens.Family2.LensLike f s t a b +error + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "error") +file :: + forall f s t a b . (Lens.Labels.HasLens f s t "file" a b) => + Lens.Family2.LensLike f s t a b +file + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file") +fileToGenerate :: + forall f s t a b . + (Lens.Labels.HasLens f s t "fileToGenerate" a b) => + Lens.Family2.LensLike f s t a b +fileToGenerate + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fileToGenerate") +insertionPoint :: + forall f s t a b . + (Lens.Labels.HasLens f s t "insertionPoint" a b) => + Lens.Family2.LensLike f s t a b +insertionPoint + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "insertionPoint") +maybe'content :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'content" a b) => + Lens.Family2.LensLike f s t a b +maybe'content + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'content") +maybe'error :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'error" a b) => + Lens.Family2.LensLike f s t a b +maybe'error + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'error") +maybe'insertionPoint :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'insertionPoint" a b) => + Lens.Family2.LensLike f s t a b +maybe'insertionPoint + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'insertionPoint") +maybe'name :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'name" a b) => + Lens.Family2.LensLike f s t a b +maybe'name + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name") +maybe'parameter :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'parameter" a b) => + Lens.Family2.LensLike f s t a b +maybe'parameter + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'parameter") +name :: + forall f s t a b . (Lens.Labels.HasLens f s t "name" a b) => + Lens.Family2.LensLike f s t a b +name + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name") +parameter :: + forall f s t a b . (Lens.Labels.HasLens f s t "parameter" a b) => + Lens.Family2.LensLike f s t a b +parameter + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "parameter") +protoFile :: + forall f s t a b . (Lens.Labels.HasLens f s t "protoFile" a b) => + Lens.Family2.LensLike f s t a b +protoFile + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "protoFile") diff --git a/src/Proto/Google/Protobuf/Descriptor.hs b/src/Proto/Google/Protobuf/Descriptor.hs new file mode 100644 --- /dev/null +++ b/src/Proto/Google/Protobuf/Descriptor.hs @@ -0,0 +1,4182 @@ +{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, GeneralizedNewtypeDeriving, + MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, + PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports#-} +module Proto.Google.Protobuf.Descriptor + (DescriptorProto(..), DescriptorProto'ExtensionRange(..), + DescriptorProto'ReservedRange(..), EnumDescriptorProto(..), + EnumOptions(..), EnumValueDescriptorProto(..), + EnumValueOptions(..), FieldDescriptorProto(..), + FieldDescriptorProto'Label(..), FieldDescriptorProto'Label(), + FieldDescriptorProto'Type(..), FieldDescriptorProto'Type(), + FieldOptions(..), FieldOptions'CType(..), FieldOptions'CType(), + FieldOptions'JSType(..), FieldOptions'JSType(), + FileDescriptorProto(..), FileDescriptorSet(..), FileOptions(..), + FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(), + GeneratedCodeInfo(..), GeneratedCodeInfo'Annotation(..), + MessageOptions(..), MethodDescriptorProto(..), MethodOptions(..), + OneofDescriptorProto(..), ServiceDescriptorProto(..), + ServiceOptions(..), SourceCodeInfo(..), + SourceCodeInfo'Location(..), UninterpretedOption(..), + UninterpretedOption'NamePart(..)) + where +import qualified Lens.Labels.Prism +import qualified Prelude +import qualified Data.Int +import qualified Data.Word +import qualified Data.ProtoLens +import qualified Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Service.Types +import qualified Lens.Family2 +import qualified Lens.Family2.Unchecked +import qualified Data.Default.Class +import qualified Data.Text +import qualified Data.Map +import qualified Data.ByteString +import qualified Data.ByteString.Char8 +import qualified Lens.Labels +import qualified Text.Read + +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' DescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' DescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.field' @:: Lens' DescriptorProto [FieldDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' DescriptorProto [FieldDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.nestedType' @:: Lens' DescriptorProto [DescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' DescriptorProto [EnumDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extensionRange' @:: Lens' DescriptorProto [DescriptorProto'ExtensionRange]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.oneofDecl' @:: Lens' DescriptorProto [OneofDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto MessageOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto (Prelude.Maybe MessageOptions)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' DescriptorProto [DescriptorProto'ReservedRange]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' DescriptorProto [Data.Text.Text]@ + -} +data DescriptorProto = DescriptorProto{_DescriptorProto'name :: + !(Prelude.Maybe Data.Text.Text), + _DescriptorProto'field :: ![FieldDescriptorProto], + _DescriptorProto'extension :: ![FieldDescriptorProto], + _DescriptorProto'nestedType :: ![DescriptorProto], + _DescriptorProto'enumType :: ![EnumDescriptorProto], + _DescriptorProto'extensionRange :: + ![DescriptorProto'ExtensionRange], + _DescriptorProto'oneofDecl :: ![OneofDescriptorProto], + _DescriptorProto'options :: !(Prelude.Maybe MessageOptions), + _DescriptorProto'reservedRange :: + ![DescriptorProto'ReservedRange], + _DescriptorProto'reservedName :: ![Data.Text.Text], + _DescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f DescriptorProto x a, a ~ b) => + Lens.Labels.HasLens f DescriptorProto DescriptorProto x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "name" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'name + (\ x__ y__ -> x__{_DescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'name + (\ x__ y__ -> x__{_DescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "field" + ([FieldDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'field + (\ x__ y__ -> x__{_DescriptorProto'field = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "extension" + ([FieldDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'extension + (\ x__ y__ -> x__{_DescriptorProto'extension = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "nestedType" + ([DescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'nestedType + (\ x__ y__ -> x__{_DescriptorProto'nestedType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "enumType" + ([EnumDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'enumType + (\ x__ y__ -> x__{_DescriptorProto'enumType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "extensionRange" + ([DescriptorProto'ExtensionRange]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'extensionRange + (\ x__ y__ -> x__{_DescriptorProto'extensionRange = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "oneofDecl" + ([OneofDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'oneofDecl + (\ x__ y__ -> x__{_DescriptorProto'oneofDecl = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "options" (MessageOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'options + (\ x__ y__ -> x__{_DescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "maybe'options" + (Prelude.Maybe MessageOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'options + (\ x__ y__ -> x__{_DescriptorProto'options = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "reservedRange" + ([DescriptorProto'ReservedRange]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'reservedRange + (\ x__ y__ -> x__{_DescriptorProto'reservedRange = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto "reservedName" + ([Data.Text.Text]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'reservedName + (\ x__ y__ -> x__{_DescriptorProto'reservedName = y__})) + Prelude.id +instance Data.Default.Class.Default DescriptorProto where + def + = DescriptorProto{_DescriptorProto'name = Prelude.Nothing, + _DescriptorProto'field = [], _DescriptorProto'extension = [], + _DescriptorProto'nestedType = [], _DescriptorProto'enumType = [], + _DescriptorProto'extensionRange = [], + _DescriptorProto'oneofDecl = [], + _DescriptorProto'options = Prelude.Nothing, + _DescriptorProto'reservedRange = [], + _DescriptorProto'reservedName = [], + _DescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message DescriptorProto where + messageName _ = Data.Text.pack "google.protobuf.DescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + field__field_descriptor + = Data.ProtoLens.FieldDescriptor "field" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "field"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + extension__field_descriptor + = Data.ProtoLens.FieldDescriptor "extension" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + nestedType__field_descriptor + = Data.ProtoLens.FieldDescriptor "nested_type" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor DescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nestedType"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + enumType__field_descriptor + = Data.ProtoLens.FieldDescriptor "enum_type" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + extensionRange__field_descriptor + = Data.ProtoLens.FieldDescriptor "extension_range" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ExtensionRange) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extensionRange"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + oneofDecl__field_descriptor + = Data.ProtoLens.FieldDescriptor "oneof_decl" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor OneofDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofDecl"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor MessageOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + reservedRange__field_descriptor + = Data.ProtoLens.FieldDescriptor "reserved_range" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ReservedRange) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedRange"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + reservedName__field_descriptor + = Data.ProtoLens.FieldDescriptor "reserved_name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedName"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, field__field_descriptor), + (Data.ProtoLens.Tag 6, extension__field_descriptor), + (Data.ProtoLens.Tag 3, nestedType__field_descriptor), + (Data.ProtoLens.Tag 4, enumType__field_descriptor), + (Data.ProtoLens.Tag 5, extensionRange__field_descriptor), + (Data.ProtoLens.Tag 8, oneofDecl__field_descriptor), + (Data.ProtoLens.Tag 7, options__field_descriptor), + (Data.ProtoLens.Tag 9, reservedRange__field_descriptor), + (Data.ProtoLens.Tag 10, reservedName__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _DescriptorProto'_unknownFields + (\ x__ y__ -> x__{_DescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@ + -} +data DescriptorProto'ExtensionRange = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start + :: + !(Prelude.Maybe + Data.Int.Int32), + _DescriptorProto'ExtensionRange'end + :: + !(Prelude.Maybe + Data.Int.Int32), + _DescriptorProto'ExtensionRange'_unknownFields + :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f DescriptorProto'ExtensionRange x + a, + a ~ b) => + Lens.Labels.HasLens f DescriptorProto'ExtensionRange + DescriptorProto'ExtensionRange + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "start" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'start + (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "maybe'start" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'start + (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "end" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end + (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "maybe'end" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end + (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__})) + Prelude.id +instance Data.Default.Class.Default DescriptorProto'ExtensionRange + where + def + = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start + = Prelude.Nothing, + _DescriptorProto'ExtensionRange'end = Prelude.Nothing, + _DescriptorProto'ExtensionRange'_unknownFields = ([])} +instance Data.ProtoLens.Message DescriptorProto'ExtensionRange + where + messageName _ + = Data.Text.pack "google.protobuf.DescriptorProto.ExtensionRange" + fieldsByTag + = let start__field_descriptor + = Data.ProtoLens.FieldDescriptor "start" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange + end__field_descriptor + = Data.ProtoLens.FieldDescriptor "end" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, start__field_descriptor), + (Data.ProtoLens.Tag 2, end__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'_unknownFields + (\ x__ y__ -> + x__{_DescriptorProto'ExtensionRange'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@ + -} +data DescriptorProto'ReservedRange = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start + :: + !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ReservedRange'end + :: + !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ReservedRange'_unknownFields + :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f DescriptorProto'ReservedRange x a, + a ~ b) => + Lens.Labels.HasLens f DescriptorProto'ReservedRange + DescriptorProto'ReservedRange + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ReservedRange "start" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start + (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ReservedRange "maybe'start" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start + (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ReservedRange "end" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end + (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f DescriptorProto'ReservedRange "maybe'end" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end + (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__})) + Prelude.id +instance Data.Default.Class.Default DescriptorProto'ReservedRange + where + def + = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start + = Prelude.Nothing, + _DescriptorProto'ReservedRange'end = Prelude.Nothing, + _DescriptorProto'ReservedRange'_unknownFields = ([])} +instance Data.ProtoLens.Message DescriptorProto'ReservedRange where + messageName _ + = Data.Text.pack "google.protobuf.DescriptorProto.ReservedRange" + fieldsByTag + = let start__field_descriptor + = Data.ProtoLens.FieldDescriptor "start" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange + end__field_descriptor + = Data.ProtoLens.FieldDescriptor "end" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end"))) + :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, start__field_descriptor), + (Data.ProtoLens.Tag 2, end__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _DescriptorProto'ReservedRange'_unknownFields + (\ x__ y__ -> + x__{_DescriptorProto'ReservedRange'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.value' @:: Lens' EnumDescriptorProto [EnumValueDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumDescriptorProto EnumOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumDescriptorProto (Prelude.Maybe EnumOptions)@ + -} +data EnumDescriptorProto = EnumDescriptorProto{_EnumDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _EnumDescriptorProto'value :: + ![EnumValueDescriptorProto], + _EnumDescriptorProto'options :: + !(Prelude.Maybe EnumOptions), + _EnumDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f EnumDescriptorProto x a, a ~ b) => + Lens.Labels.HasLens f EnumDescriptorProto EnumDescriptorProto x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumDescriptorProto "name" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name + (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name + (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumDescriptorProto "value" + ([EnumValueDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumDescriptorProto'value + (\ x__ y__ -> x__{_EnumDescriptorProto'value = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumDescriptorProto "options" (EnumOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options + (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumDescriptorProto "maybe'options" + (Prelude.Maybe EnumOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options + (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__})) + Prelude.id +instance Data.Default.Class.Default EnumDescriptorProto where + def + = EnumDescriptorProto{_EnumDescriptorProto'name = Prelude.Nothing, + _EnumDescriptorProto'value = [], + _EnumDescriptorProto'options = Prelude.Nothing, + _EnumDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message EnumDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.EnumDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto + value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumValueDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value"))) + :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, value__field_descriptor), + (Data.ProtoLens.Tag 3, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _EnumDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_EnumDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.allowAlias' @:: Lens' EnumOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'allowAlias' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumOptions [UninterpretedOption]@ + -} +data EnumOptions = EnumOptions{_EnumOptions'allowAlias :: + !(Prelude.Maybe Prelude.Bool), + _EnumOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _EnumOptions'uninterpretedOption :: ![UninterpretedOption], + _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f EnumOptions x a, a ~ b) => + Lens.Labels.HasLens f EnumOptions EnumOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumOptions "allowAlias" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias + (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumOptions "maybe'allowAlias" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias + (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumOptions'deprecated + (\ x__ y__ -> x__{_EnumOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumOptions'deprecated + (\ x__ y__ -> x__{_EnumOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumOptions'uninterpretedOption + (\ x__ y__ -> x__{_EnumOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default EnumOptions where + def + = EnumOptions{_EnumOptions'allowAlias = Prelude.Nothing, + _EnumOptions'deprecated = Prelude.Nothing, + _EnumOptions'uninterpretedOption = [], + _EnumOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message EnumOptions where + messageName _ = Data.Text.pack "google.protobuf.EnumOptions" + fieldsByTag + = let allowAlias__field_descriptor + = Data.ProtoLens.FieldDescriptor "allow_alias" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'allowAlias"))) + :: Data.ProtoLens.FieldDescriptor EnumOptions + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor EnumOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor EnumOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 2, allowAlias__field_descriptor), + (Data.ProtoLens.Tag 3, deprecated__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _EnumOptions'_unknownFields + (\ x__ y__ -> x__{_EnumOptions'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumValueDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' EnumValueDescriptorProto Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumValueDescriptorProto EnumValueOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe EnumValueOptions)@ + -} +data EnumValueDescriptorProto = EnumValueDescriptorProto{_EnumValueDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _EnumValueDescriptorProto'number :: + !(Prelude.Maybe Data.Int.Int32), + _EnumValueDescriptorProto'options :: + !(Prelude.Maybe EnumValueOptions), + _EnumValueDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f EnumValueDescriptorProto x a, + a ~ b) => + Lens.Labels.HasLens f EnumValueDescriptorProto + EnumValueDescriptorProto + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "name" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name + (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name + (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "number" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number + (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'number" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number + (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "options" + (EnumValueOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options + (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'options" + (Prelude.Maybe EnumValueOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options + (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__})) + Prelude.id +instance Data.Default.Class.Default EnumValueDescriptorProto where + def + = EnumValueDescriptorProto{_EnumValueDescriptorProto'name = + Prelude.Nothing, + _EnumValueDescriptorProto'number = Prelude.Nothing, + _EnumValueDescriptorProto'options = Prelude.Nothing, + _EnumValueDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message EnumValueDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.EnumValueDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto + number__field_descriptor + = Data.ProtoLens.FieldDescriptor "number" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number"))) + :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumValueOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, number__field_descriptor), + (Data.ProtoLens.Tag 3, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_EnumValueDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumValueOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumValueOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumValueOptions [UninterpretedOption]@ + -} +data EnumValueOptions = EnumValueOptions{_EnumValueOptions'deprecated + :: !(Prelude.Maybe Prelude.Bool), + _EnumValueOptions'uninterpretedOption :: + ![UninterpretedOption], + _EnumValueOptions'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f EnumValueOptions x a, a ~ b) => + Lens.Labels.HasLens f EnumValueOptions EnumValueOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated + (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated + (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f EnumValueOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _EnumValueOptions'uninterpretedOption + (\ x__ y__ -> x__{_EnumValueOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default EnumValueOptions where + def + = EnumValueOptions{_EnumValueOptions'deprecated = Prelude.Nothing, + _EnumValueOptions'uninterpretedOption = [], + _EnumValueOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message EnumValueOptions where + messageName _ = Data.Text.pack "google.protobuf.EnumValueOptions" + fieldsByTag + = let deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor EnumValueOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor EnumValueOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, deprecated__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _EnumValueOptions'_unknownFields + (\ x__ y__ -> x__{_EnumValueOptions'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' FieldDescriptorProto Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.label' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Label@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'label' @:: Lens' FieldDescriptorProto + (Prelude.Maybe FieldDescriptorProto'Label)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Type@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' FieldDescriptorProto + (Prelude.Maybe FieldDescriptorProto'Type)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.typeName' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'typeName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extendee' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'extendee' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.defaultValue' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'defaultValue' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.oneofIndex' @:: Lens' FieldDescriptorProto Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'oneofIndex' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.jsonName' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FieldDescriptorProto FieldOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldOptions)@ + -} +data FieldDescriptorProto = FieldDescriptorProto{_FieldDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _FieldDescriptorProto'number :: + !(Prelude.Maybe Data.Int.Int32), + _FieldDescriptorProto'label :: + !(Prelude.Maybe FieldDescriptorProto'Label), + _FieldDescriptorProto'type' :: + !(Prelude.Maybe FieldDescriptorProto'Type), + _FieldDescriptorProto'typeName :: + !(Prelude.Maybe Data.Text.Text), + _FieldDescriptorProto'extendee :: + !(Prelude.Maybe Data.Text.Text), + _FieldDescriptorProto'defaultValue :: + !(Prelude.Maybe Data.Text.Text), + _FieldDescriptorProto'oneofIndex :: + !(Prelude.Maybe Data.Int.Int32), + _FieldDescriptorProto'jsonName :: + !(Prelude.Maybe Data.Text.Text), + _FieldDescriptorProto'options :: + !(Prelude.Maybe FieldOptions), + _FieldDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f FieldDescriptorProto x a, + a ~ b) => + Lens.Labels.HasLens f FieldDescriptorProto FieldDescriptorProto x a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "name" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name + (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name + (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "number" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number + (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'number" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number + (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "label" + (FieldDescriptorProto'Label) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label + (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'label" + (Prelude.Maybe FieldDescriptorProto'Label) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label + (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "type'" + (FieldDescriptorProto'Type) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type' + (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'type'" + (Prelude.Maybe FieldDescriptorProto'Type) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type' + (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "typeName" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName + (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'typeName" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName + (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "extendee" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee + (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'extendee" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee + (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "defaultValue" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue + (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'defaultValue" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue + (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "oneofIndex" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex + (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'oneofIndex" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex + (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "jsonName" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName + (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'jsonName" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName + (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "options" + (FieldOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options + (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldDescriptorProto "maybe'options" + (Prelude.Maybe FieldOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options + (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__})) + Prelude.id +instance Data.Default.Class.Default FieldDescriptorProto where + def + = FieldDescriptorProto{_FieldDescriptorProto'name = + Prelude.Nothing, + _FieldDescriptorProto'number = Prelude.Nothing, + _FieldDescriptorProto'label = Prelude.Nothing, + _FieldDescriptorProto'type' = Prelude.Nothing, + _FieldDescriptorProto'typeName = Prelude.Nothing, + _FieldDescriptorProto'extendee = Prelude.Nothing, + _FieldDescriptorProto'defaultValue = Prelude.Nothing, + _FieldDescriptorProto'oneofIndex = Prelude.Nothing, + _FieldDescriptorProto'jsonName = Prelude.Nothing, + _FieldDescriptorProto'options = Prelude.Nothing, + _FieldDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message FieldDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FieldDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + number__field_descriptor + = Data.ProtoLens.FieldDescriptor "number" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + label__field_descriptor + = Data.ProtoLens.FieldDescriptor "label" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Label) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'label"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + type'__field_descriptor + = Data.ProtoLens.FieldDescriptor "type" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Type) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'type'"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + typeName__field_descriptor + = Data.ProtoLens.FieldDescriptor "type_name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'typeName"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + extendee__field_descriptor + = Data.ProtoLens.FieldDescriptor "extendee" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'extendee"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + defaultValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "default_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'defaultValue"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + oneofIndex__field_descriptor + = Data.ProtoLens.FieldDescriptor "oneof_index" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'oneofIndex"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + jsonName__field_descriptor + = Data.ProtoLens.FieldDescriptor "json_name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jsonName"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 3, number__field_descriptor), + (Data.ProtoLens.Tag 4, label__field_descriptor), + (Data.ProtoLens.Tag 5, type'__field_descriptor), + (Data.ProtoLens.Tag 6, typeName__field_descriptor), + (Data.ProtoLens.Tag 2, extendee__field_descriptor), + (Data.ProtoLens.Tag 7, defaultValue__field_descriptor), + (Data.ProtoLens.Tag 9, oneofIndex__field_descriptor), + (Data.ProtoLens.Tag 10, jsonName__field_descriptor), + (Data.ProtoLens.Tag 8, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _FieldDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_FieldDescriptorProto'_unknownFields = y__}) +data FieldDescriptorProto'Label = FieldDescriptorProto'LABEL_OPTIONAL + | FieldDescriptorProto'LABEL_REQUIRED + | FieldDescriptorProto'LABEL_REPEATED + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.Default.Class.Default FieldDescriptorProto'Label + where + def = FieldDescriptorProto'LABEL_OPTIONAL +instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Label + where + fieldDefault = FieldDescriptorProto'LABEL_OPTIONAL +instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Label + where + maybeToEnum 1 = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL + maybeToEnum 2 = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED + maybeToEnum 3 = Prelude.Just FieldDescriptorProto'LABEL_REPEATED + maybeToEnum _ = Prelude.Nothing + showEnum FieldDescriptorProto'LABEL_OPTIONAL = "LABEL_OPTIONAL" + showEnum FieldDescriptorProto'LABEL_REQUIRED = "LABEL_REQUIRED" + showEnum FieldDescriptorProto'LABEL_REPEATED = "LABEL_REPEATED" + readEnum "LABEL_OPTIONAL" + = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL + readEnum "LABEL_REQUIRED" + = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED + readEnum "LABEL_REPEATED" + = Prelude.Just FieldDescriptorProto'LABEL_REPEATED + readEnum _ = Prelude.Nothing +instance Prelude.Enum FieldDescriptorProto'Label where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) "toEnum: unknown value for enum Label: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldDescriptorProto'LABEL_OPTIONAL = 1 + fromEnum FieldDescriptorProto'LABEL_REQUIRED = 2 + fromEnum FieldDescriptorProto'LABEL_REPEATED = 3 + succ FieldDescriptorProto'LABEL_REPEATED + = Prelude.error + "FieldDescriptorProto'Label.succ: bad argument FieldDescriptorProto'LABEL_REPEATED. This value would be out of bounds." + succ FieldDescriptorProto'LABEL_OPTIONAL + = FieldDescriptorProto'LABEL_REQUIRED + succ FieldDescriptorProto'LABEL_REQUIRED + = FieldDescriptorProto'LABEL_REPEATED + pred FieldDescriptorProto'LABEL_OPTIONAL + = Prelude.error + "FieldDescriptorProto'Label.pred: bad argument FieldDescriptorProto'LABEL_OPTIONAL. This value would be out of bounds." + pred FieldDescriptorProto'LABEL_REQUIRED + = FieldDescriptorProto'LABEL_OPTIONAL + pred FieldDescriptorProto'LABEL_REPEATED + = FieldDescriptorProto'LABEL_REQUIRED + enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom + enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo + enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen + enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo +instance Prelude.Bounded FieldDescriptorProto'Label where + minBound = FieldDescriptorProto'LABEL_OPTIONAL + maxBound = FieldDescriptorProto'LABEL_REPEATED +data FieldDescriptorProto'Type = FieldDescriptorProto'TYPE_DOUBLE + | FieldDescriptorProto'TYPE_FLOAT + | FieldDescriptorProto'TYPE_INT64 + | FieldDescriptorProto'TYPE_UINT64 + | FieldDescriptorProto'TYPE_INT32 + | FieldDescriptorProto'TYPE_FIXED64 + | FieldDescriptorProto'TYPE_FIXED32 + | FieldDescriptorProto'TYPE_BOOL + | FieldDescriptorProto'TYPE_STRING + | FieldDescriptorProto'TYPE_GROUP + | FieldDescriptorProto'TYPE_MESSAGE + | FieldDescriptorProto'TYPE_BYTES + | FieldDescriptorProto'TYPE_UINT32 + | FieldDescriptorProto'TYPE_ENUM + | FieldDescriptorProto'TYPE_SFIXED32 + | FieldDescriptorProto'TYPE_SFIXED64 + | FieldDescriptorProto'TYPE_SINT32 + | FieldDescriptorProto'TYPE_SINT64 + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.Default.Class.Default FieldDescriptorProto'Type where + def = FieldDescriptorProto'TYPE_DOUBLE +instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Type + where + fieldDefault = FieldDescriptorProto'TYPE_DOUBLE +instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Type where + maybeToEnum 1 = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE + maybeToEnum 2 = Prelude.Just FieldDescriptorProto'TYPE_FLOAT + maybeToEnum 3 = Prelude.Just FieldDescriptorProto'TYPE_INT64 + maybeToEnum 4 = Prelude.Just FieldDescriptorProto'TYPE_UINT64 + maybeToEnum 5 = Prelude.Just FieldDescriptorProto'TYPE_INT32 + maybeToEnum 6 = Prelude.Just FieldDescriptorProto'TYPE_FIXED64 + maybeToEnum 7 = Prelude.Just FieldDescriptorProto'TYPE_FIXED32 + maybeToEnum 8 = Prelude.Just FieldDescriptorProto'TYPE_BOOL + maybeToEnum 9 = Prelude.Just FieldDescriptorProto'TYPE_STRING + maybeToEnum 10 = Prelude.Just FieldDescriptorProto'TYPE_GROUP + maybeToEnum 11 = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE + maybeToEnum 12 = Prelude.Just FieldDescriptorProto'TYPE_BYTES + maybeToEnum 13 = Prelude.Just FieldDescriptorProto'TYPE_UINT32 + maybeToEnum 14 = Prelude.Just FieldDescriptorProto'TYPE_ENUM + maybeToEnum 15 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32 + maybeToEnum 16 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64 + maybeToEnum 17 = Prelude.Just FieldDescriptorProto'TYPE_SINT32 + maybeToEnum 18 = Prelude.Just FieldDescriptorProto'TYPE_SINT64 + maybeToEnum _ = Prelude.Nothing + showEnum FieldDescriptorProto'TYPE_DOUBLE = "TYPE_DOUBLE" + showEnum FieldDescriptorProto'TYPE_FLOAT = "TYPE_FLOAT" + showEnum FieldDescriptorProto'TYPE_INT64 = "TYPE_INT64" + showEnum FieldDescriptorProto'TYPE_UINT64 = "TYPE_UINT64" + showEnum FieldDescriptorProto'TYPE_INT32 = "TYPE_INT32" + showEnum FieldDescriptorProto'TYPE_FIXED64 = "TYPE_FIXED64" + showEnum FieldDescriptorProto'TYPE_FIXED32 = "TYPE_FIXED32" + showEnum FieldDescriptorProto'TYPE_BOOL = "TYPE_BOOL" + showEnum FieldDescriptorProto'TYPE_STRING = "TYPE_STRING" + showEnum FieldDescriptorProto'TYPE_GROUP = "TYPE_GROUP" + showEnum FieldDescriptorProto'TYPE_MESSAGE = "TYPE_MESSAGE" + showEnum FieldDescriptorProto'TYPE_BYTES = "TYPE_BYTES" + showEnum FieldDescriptorProto'TYPE_UINT32 = "TYPE_UINT32" + showEnum FieldDescriptorProto'TYPE_ENUM = "TYPE_ENUM" + showEnum FieldDescriptorProto'TYPE_SFIXED32 = "TYPE_SFIXED32" + showEnum FieldDescriptorProto'TYPE_SFIXED64 = "TYPE_SFIXED64" + showEnum FieldDescriptorProto'TYPE_SINT32 = "TYPE_SINT32" + showEnum FieldDescriptorProto'TYPE_SINT64 = "TYPE_SINT64" + readEnum "TYPE_DOUBLE" + = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE + readEnum "TYPE_FLOAT" + = Prelude.Just FieldDescriptorProto'TYPE_FLOAT + readEnum "TYPE_INT64" + = Prelude.Just FieldDescriptorProto'TYPE_INT64 + readEnum "TYPE_UINT64" + = Prelude.Just FieldDescriptorProto'TYPE_UINT64 + readEnum "TYPE_INT32" + = Prelude.Just FieldDescriptorProto'TYPE_INT32 + readEnum "TYPE_FIXED64" + = Prelude.Just FieldDescriptorProto'TYPE_FIXED64 + readEnum "TYPE_FIXED32" + = Prelude.Just FieldDescriptorProto'TYPE_FIXED32 + readEnum "TYPE_BOOL" = Prelude.Just FieldDescriptorProto'TYPE_BOOL + readEnum "TYPE_STRING" + = Prelude.Just FieldDescriptorProto'TYPE_STRING + readEnum "TYPE_GROUP" + = Prelude.Just FieldDescriptorProto'TYPE_GROUP + readEnum "TYPE_MESSAGE" + = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE + readEnum "TYPE_BYTES" + = Prelude.Just FieldDescriptorProto'TYPE_BYTES + readEnum "TYPE_UINT32" + = Prelude.Just FieldDescriptorProto'TYPE_UINT32 + readEnum "TYPE_ENUM" = Prelude.Just FieldDescriptorProto'TYPE_ENUM + readEnum "TYPE_SFIXED32" + = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32 + readEnum "TYPE_SFIXED64" + = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64 + readEnum "TYPE_SINT32" + = Prelude.Just FieldDescriptorProto'TYPE_SINT32 + readEnum "TYPE_SINT64" + = Prelude.Just FieldDescriptorProto'TYPE_SINT64 + readEnum _ = Prelude.Nothing +instance Prelude.Enum FieldDescriptorProto'Type where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) "toEnum: unknown value for enum Type: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldDescriptorProto'TYPE_DOUBLE = 1 + fromEnum FieldDescriptorProto'TYPE_FLOAT = 2 + fromEnum FieldDescriptorProto'TYPE_INT64 = 3 + fromEnum FieldDescriptorProto'TYPE_UINT64 = 4 + fromEnum FieldDescriptorProto'TYPE_INT32 = 5 + fromEnum FieldDescriptorProto'TYPE_FIXED64 = 6 + fromEnum FieldDescriptorProto'TYPE_FIXED32 = 7 + fromEnum FieldDescriptorProto'TYPE_BOOL = 8 + fromEnum FieldDescriptorProto'TYPE_STRING = 9 + fromEnum FieldDescriptorProto'TYPE_GROUP = 10 + fromEnum FieldDescriptorProto'TYPE_MESSAGE = 11 + fromEnum FieldDescriptorProto'TYPE_BYTES = 12 + fromEnum FieldDescriptorProto'TYPE_UINT32 = 13 + fromEnum FieldDescriptorProto'TYPE_ENUM = 14 + fromEnum FieldDescriptorProto'TYPE_SFIXED32 = 15 + fromEnum FieldDescriptorProto'TYPE_SFIXED64 = 16 + fromEnum FieldDescriptorProto'TYPE_SINT32 = 17 + fromEnum FieldDescriptorProto'TYPE_SINT64 = 18 + succ FieldDescriptorProto'TYPE_SINT64 + = Prelude.error + "FieldDescriptorProto'Type.succ: bad argument FieldDescriptorProto'TYPE_SINT64. This value would be out of bounds." + succ FieldDescriptorProto'TYPE_DOUBLE + = FieldDescriptorProto'TYPE_FLOAT + succ FieldDescriptorProto'TYPE_FLOAT + = FieldDescriptorProto'TYPE_INT64 + succ FieldDescriptorProto'TYPE_INT64 + = FieldDescriptorProto'TYPE_UINT64 + succ FieldDescriptorProto'TYPE_UINT64 + = FieldDescriptorProto'TYPE_INT32 + succ FieldDescriptorProto'TYPE_INT32 + = FieldDescriptorProto'TYPE_FIXED64 + succ FieldDescriptorProto'TYPE_FIXED64 + = FieldDescriptorProto'TYPE_FIXED32 + succ FieldDescriptorProto'TYPE_FIXED32 + = FieldDescriptorProto'TYPE_BOOL + succ FieldDescriptorProto'TYPE_BOOL + = FieldDescriptorProto'TYPE_STRING + succ FieldDescriptorProto'TYPE_STRING + = FieldDescriptorProto'TYPE_GROUP + succ FieldDescriptorProto'TYPE_GROUP + = FieldDescriptorProto'TYPE_MESSAGE + succ FieldDescriptorProto'TYPE_MESSAGE + = FieldDescriptorProto'TYPE_BYTES + succ FieldDescriptorProto'TYPE_BYTES + = FieldDescriptorProto'TYPE_UINT32 + succ FieldDescriptorProto'TYPE_UINT32 + = FieldDescriptorProto'TYPE_ENUM + succ FieldDescriptorProto'TYPE_ENUM + = FieldDescriptorProto'TYPE_SFIXED32 + succ FieldDescriptorProto'TYPE_SFIXED32 + = FieldDescriptorProto'TYPE_SFIXED64 + succ FieldDescriptorProto'TYPE_SFIXED64 + = FieldDescriptorProto'TYPE_SINT32 + succ FieldDescriptorProto'TYPE_SINT32 + = FieldDescriptorProto'TYPE_SINT64 + pred FieldDescriptorProto'TYPE_DOUBLE + = Prelude.error + "FieldDescriptorProto'Type.pred: bad argument FieldDescriptorProto'TYPE_DOUBLE. This value would be out of bounds." + pred FieldDescriptorProto'TYPE_FLOAT + = FieldDescriptorProto'TYPE_DOUBLE + pred FieldDescriptorProto'TYPE_INT64 + = FieldDescriptorProto'TYPE_FLOAT + pred FieldDescriptorProto'TYPE_UINT64 + = FieldDescriptorProto'TYPE_INT64 + pred FieldDescriptorProto'TYPE_INT32 + = FieldDescriptorProto'TYPE_UINT64 + pred FieldDescriptorProto'TYPE_FIXED64 + = FieldDescriptorProto'TYPE_INT32 + pred FieldDescriptorProto'TYPE_FIXED32 + = FieldDescriptorProto'TYPE_FIXED64 + pred FieldDescriptorProto'TYPE_BOOL + = FieldDescriptorProto'TYPE_FIXED32 + pred FieldDescriptorProto'TYPE_STRING + = FieldDescriptorProto'TYPE_BOOL + pred FieldDescriptorProto'TYPE_GROUP + = FieldDescriptorProto'TYPE_STRING + pred FieldDescriptorProto'TYPE_MESSAGE + = FieldDescriptorProto'TYPE_GROUP + pred FieldDescriptorProto'TYPE_BYTES + = FieldDescriptorProto'TYPE_MESSAGE + pred FieldDescriptorProto'TYPE_UINT32 + = FieldDescriptorProto'TYPE_BYTES + pred FieldDescriptorProto'TYPE_ENUM + = FieldDescriptorProto'TYPE_UINT32 + pred FieldDescriptorProto'TYPE_SFIXED32 + = FieldDescriptorProto'TYPE_ENUM + pred FieldDescriptorProto'TYPE_SFIXED64 + = FieldDescriptorProto'TYPE_SFIXED32 + pred FieldDescriptorProto'TYPE_SINT32 + = FieldDescriptorProto'TYPE_SFIXED64 + pred FieldDescriptorProto'TYPE_SINT64 + = FieldDescriptorProto'TYPE_SINT32 + enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom + enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo + enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen + enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo +instance Prelude.Bounded FieldDescriptorProto'Type where + minBound = FieldDescriptorProto'TYPE_DOUBLE + maxBound = FieldDescriptorProto'TYPE_SINT64 +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.ctype' @:: Lens' FieldOptions FieldOptions'CType@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ctype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'CType)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.packed' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'packed' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.jstype' @:: Lens' FieldOptions FieldOptions'JSType@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jstype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'JSType)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.lazy' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'lazy' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.weak' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'weak' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FieldOptions [UninterpretedOption]@ + -} +data FieldOptions = FieldOptions{_FieldOptions'ctype :: + !(Prelude.Maybe FieldOptions'CType), + _FieldOptions'packed :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'jstype :: !(Prelude.Maybe FieldOptions'JSType), + _FieldOptions'lazy :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'weak :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'uninterpretedOption :: ![UninterpretedOption], + _FieldOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f FieldOptions x a, a ~ b) => + Lens.Labels.HasLens f FieldOptions FieldOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "ctype" (FieldOptions'CType) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'ctype + (\ x__ y__ -> x__{_FieldOptions'ctype = y__})) + (Data.ProtoLens.maybeLens FieldOptions'STRING) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'ctype" + (Prelude.Maybe FieldOptions'CType) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'ctype + (\ x__ y__ -> x__{_FieldOptions'ctype = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "packed" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'packed + (\ x__ y__ -> x__{_FieldOptions'packed = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'packed" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'packed + (\ x__ y__ -> x__{_FieldOptions'packed = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "jstype" (FieldOptions'JSType) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'jstype + (\ x__ y__ -> x__{_FieldOptions'jstype = y__})) + (Data.ProtoLens.maybeLens FieldOptions'JS_NORMAL) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'jstype" + (Prelude.Maybe FieldOptions'JSType) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'jstype + (\ x__ y__ -> x__{_FieldOptions'jstype = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "lazy" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'lazy + (\ x__ y__ -> x__{_FieldOptions'lazy = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'lazy" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'lazy + (\ x__ y__ -> x__{_FieldOptions'lazy = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'deprecated + (\ x__ y__ -> x__{_FieldOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'deprecated + (\ x__ y__ -> x__{_FieldOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "weak" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'weak + (\ x__ y__ -> x__{_FieldOptions'weak = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "maybe'weak" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'weak + (\ x__ y__ -> x__{_FieldOptions'weak = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FieldOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FieldOptions'uninterpretedOption + (\ x__ y__ -> x__{_FieldOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default FieldOptions where + def + = FieldOptions{_FieldOptions'ctype = Prelude.Nothing, + _FieldOptions'packed = Prelude.Nothing, + _FieldOptions'jstype = Prelude.Nothing, + _FieldOptions'lazy = Prelude.Nothing, + _FieldOptions'deprecated = Prelude.Nothing, + _FieldOptions'weak = Prelude.Nothing, + _FieldOptions'uninterpretedOption = [], + _FieldOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message FieldOptions where + messageName _ = Data.Text.pack "google.protobuf.FieldOptions" + fieldsByTag + = let ctype__field_descriptor + = Data.ProtoLens.FieldDescriptor "ctype" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'CType) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'ctype"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + packed__field_descriptor + = Data.ProtoLens.FieldDescriptor "packed" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'packed"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + jstype__field_descriptor + = Data.ProtoLens.FieldDescriptor "jstype" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'JSType) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jstype"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + lazy__field_descriptor + = Data.ProtoLens.FieldDescriptor "lazy" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'lazy"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + weak__field_descriptor + = Data.ProtoLens.FieldDescriptor "weak" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'weak"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor FieldOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, ctype__field_descriptor), + (Data.ProtoLens.Tag 2, packed__field_descriptor), + (Data.ProtoLens.Tag 6, jstype__field_descriptor), + (Data.ProtoLens.Tag 5, lazy__field_descriptor), + (Data.ProtoLens.Tag 3, deprecated__field_descriptor), + (Data.ProtoLens.Tag 10, weak__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _FieldOptions'_unknownFields + (\ x__ y__ -> x__{_FieldOptions'_unknownFields = y__}) +data FieldOptions'CType = FieldOptions'STRING + | FieldOptions'CORD + | FieldOptions'STRING_PIECE + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.Default.Class.Default FieldOptions'CType where + def = FieldOptions'STRING +instance Data.ProtoLens.FieldDefault FieldOptions'CType where + fieldDefault = FieldOptions'STRING +instance Data.ProtoLens.MessageEnum FieldOptions'CType where + maybeToEnum 0 = Prelude.Just FieldOptions'STRING + maybeToEnum 1 = Prelude.Just FieldOptions'CORD + maybeToEnum 2 = Prelude.Just FieldOptions'STRING_PIECE + maybeToEnum _ = Prelude.Nothing + showEnum FieldOptions'STRING = "STRING" + showEnum FieldOptions'CORD = "CORD" + showEnum FieldOptions'STRING_PIECE = "STRING_PIECE" + readEnum "STRING" = Prelude.Just FieldOptions'STRING + readEnum "CORD" = Prelude.Just FieldOptions'CORD + readEnum "STRING_PIECE" = Prelude.Just FieldOptions'STRING_PIECE + readEnum _ = Prelude.Nothing +instance Prelude.Enum FieldOptions'CType where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) "toEnum: unknown value for enum CType: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldOptions'STRING = 0 + fromEnum FieldOptions'CORD = 1 + fromEnum FieldOptions'STRING_PIECE = 2 + succ FieldOptions'STRING_PIECE + = Prelude.error + "FieldOptions'CType.succ: bad argument FieldOptions'STRING_PIECE. This value would be out of bounds." + succ FieldOptions'STRING = FieldOptions'CORD + succ FieldOptions'CORD = FieldOptions'STRING_PIECE + pred FieldOptions'STRING + = Prelude.error + "FieldOptions'CType.pred: bad argument FieldOptions'STRING. This value would be out of bounds." + pred FieldOptions'CORD = FieldOptions'STRING + pred FieldOptions'STRING_PIECE = FieldOptions'CORD + enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom + enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo + enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen + enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo +instance Prelude.Bounded FieldOptions'CType where + minBound = FieldOptions'STRING + maxBound = FieldOptions'STRING_PIECE +data FieldOptions'JSType = FieldOptions'JS_NORMAL + | FieldOptions'JS_STRING + | FieldOptions'JS_NUMBER + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.Default.Class.Default FieldOptions'JSType where + def = FieldOptions'JS_NORMAL +instance Data.ProtoLens.FieldDefault FieldOptions'JSType where + fieldDefault = FieldOptions'JS_NORMAL +instance Data.ProtoLens.MessageEnum FieldOptions'JSType where + maybeToEnum 0 = Prelude.Just FieldOptions'JS_NORMAL + maybeToEnum 1 = Prelude.Just FieldOptions'JS_STRING + maybeToEnum 2 = Prelude.Just FieldOptions'JS_NUMBER + maybeToEnum _ = Prelude.Nothing + showEnum FieldOptions'JS_NORMAL = "JS_NORMAL" + showEnum FieldOptions'JS_STRING = "JS_STRING" + showEnum FieldOptions'JS_NUMBER = "JS_NUMBER" + readEnum "JS_NORMAL" = Prelude.Just FieldOptions'JS_NORMAL + readEnum "JS_STRING" = Prelude.Just FieldOptions'JS_STRING + readEnum "JS_NUMBER" = Prelude.Just FieldOptions'JS_NUMBER + readEnum _ = Prelude.Nothing +instance Prelude.Enum FieldOptions'JSType where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) "toEnum: unknown value for enum JSType: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldOptions'JS_NORMAL = 0 + fromEnum FieldOptions'JS_STRING = 1 + fromEnum FieldOptions'JS_NUMBER = 2 + succ FieldOptions'JS_NUMBER + = Prelude.error + "FieldOptions'JSType.succ: bad argument FieldOptions'JS_NUMBER. This value would be out of bounds." + succ FieldOptions'JS_NORMAL = FieldOptions'JS_STRING + succ FieldOptions'JS_STRING = FieldOptions'JS_NUMBER + pred FieldOptions'JS_NORMAL + = Prelude.error + "FieldOptions'JSType.pred: bad argument FieldOptions'JS_NORMAL. This value would be out of bounds." + pred FieldOptions'JS_STRING = FieldOptions'JS_NORMAL + pred FieldOptions'JS_NUMBER = FieldOptions'JS_STRING + enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom + enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo + enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen + enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo +instance Prelude.Bounded FieldOptions'JSType where + minBound = FieldOptions'JS_NORMAL + maxBound = FieldOptions'JS_NUMBER +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FileDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.package' @:: Lens' FileDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'package' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.dependency' @:: Lens' FileDescriptorProto [Data.Text.Text]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.publicDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.weakDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.messageType' @:: Lens' FileDescriptorProto [DescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' FileDescriptorProto [EnumDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.service' @:: Lens' FileDescriptorProto [ServiceDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' FileDescriptorProto [FieldDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FileDescriptorProto FileOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FileDescriptorProto (Prelude.Maybe FileOptions)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.sourceCodeInfo' @:: Lens' FileDescriptorProto SourceCodeInfo@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceCodeInfo' @:: Lens' FileDescriptorProto (Prelude.Maybe SourceCodeInfo)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.syntax' @:: Lens' FileDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'syntax' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@ + -} +data FileDescriptorProto = FileDescriptorProto{_FileDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'package :: + !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'dependency :: ![Data.Text.Text], + _FileDescriptorProto'publicDependency :: + ![Data.Int.Int32], + _FileDescriptorProto'weakDependency :: + ![Data.Int.Int32], + _FileDescriptorProto'messageType :: + ![DescriptorProto], + _FileDescriptorProto'enumType :: + ![EnumDescriptorProto], + _FileDescriptorProto'service :: + ![ServiceDescriptorProto], + _FileDescriptorProto'extension :: + ![FieldDescriptorProto], + _FileDescriptorProto'options :: + !(Prelude.Maybe FileOptions), + _FileDescriptorProto'sourceCodeInfo :: + !(Prelude.Maybe SourceCodeInfo), + _FileDescriptorProto'syntax :: + !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f FileDescriptorProto x a, a ~ b) => + Lens.Labels.HasLens f FileDescriptorProto FileDescriptorProto x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "name" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'name + (\ x__ y__ -> x__{_FileDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'name + (\ x__ y__ -> x__{_FileDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "package" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'package + (\ x__ y__ -> x__{_FileDescriptorProto'package = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "maybe'package" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'package + (\ x__ y__ -> x__{_FileDescriptorProto'package = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "dependency" + ([Data.Text.Text]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'dependency + (\ x__ y__ -> x__{_FileDescriptorProto'dependency = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "publicDependency" + ([Data.Int.Int32]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'publicDependency + (\ x__ y__ -> x__{_FileDescriptorProto'publicDependency = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "weakDependency" + ([Data.Int.Int32]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'weakDependency + (\ x__ y__ -> x__{_FileDescriptorProto'weakDependency = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "messageType" + ([DescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'messageType + (\ x__ y__ -> x__{_FileDescriptorProto'messageType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "enumType" + ([EnumDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'enumType + (\ x__ y__ -> x__{_FileDescriptorProto'enumType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "service" + ([ServiceDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'service + (\ x__ y__ -> x__{_FileDescriptorProto'service = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "extension" + ([FieldDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'extension + (\ x__ y__ -> x__{_FileDescriptorProto'extension = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "options" (FileOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'options + (\ x__ y__ -> x__{_FileDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "maybe'options" + (Prelude.Maybe FileOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'options + (\ x__ y__ -> x__{_FileDescriptorProto'options = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "sourceCodeInfo" + (SourceCodeInfo) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'sourceCodeInfo + (\ x__ y__ -> x__{_FileDescriptorProto'sourceCodeInfo = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "maybe'sourceCodeInfo" + (Prelude.Maybe SourceCodeInfo) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'sourceCodeInfo + (\ x__ y__ -> x__{_FileDescriptorProto'sourceCodeInfo = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "syntax" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'syntax + (\ x__ y__ -> x__{_FileDescriptorProto'syntax = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorProto "maybe'syntax" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorProto'syntax + (\ x__ y__ -> x__{_FileDescriptorProto'syntax = y__})) + Prelude.id +instance Data.Default.Class.Default FileDescriptorProto where + def + = FileDescriptorProto{_FileDescriptorProto'name = Prelude.Nothing, + _FileDescriptorProto'package = Prelude.Nothing, + _FileDescriptorProto'dependency = [], + _FileDescriptorProto'publicDependency = [], + _FileDescriptorProto'weakDependency = [], + _FileDescriptorProto'messageType = [], + _FileDescriptorProto'enumType = [], + _FileDescriptorProto'service = [], + _FileDescriptorProto'extension = [], + _FileDescriptorProto'options = Prelude.Nothing, + _FileDescriptorProto'sourceCodeInfo = Prelude.Nothing, + _FileDescriptorProto'syntax = Prelude.Nothing, + _FileDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message FileDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FileDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + package__field_descriptor + = Data.ProtoLens.FieldDescriptor "package" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'package"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + dependency__field_descriptor + = Data.ProtoLens.FieldDescriptor "dependency" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "dependency"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + publicDependency__field_descriptor + = Data.ProtoLens.FieldDescriptor "public_dependency" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "publicDependency"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + weakDependency__field_descriptor + = Data.ProtoLens.FieldDescriptor "weak_dependency" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weakDependency"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + messageType__field_descriptor + = Data.ProtoLens.FieldDescriptor "message_type" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor DescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "messageType"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + enumType__field_descriptor + = Data.ProtoLens.FieldDescriptor "enum_type" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + service__field_descriptor + = Data.ProtoLens.FieldDescriptor "service" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor ServiceDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "service"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + extension__field_descriptor + = Data.ProtoLens.FieldDescriptor "extension" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FileOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + sourceCodeInfo__field_descriptor + = Data.ProtoLens.FieldDescriptor "source_code_info" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'sourceCodeInfo"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + syntax__field_descriptor + = Data.ProtoLens.FieldDescriptor "syntax" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'syntax"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, package__field_descriptor), + (Data.ProtoLens.Tag 3, dependency__field_descriptor), + (Data.ProtoLens.Tag 10, publicDependency__field_descriptor), + (Data.ProtoLens.Tag 11, weakDependency__field_descriptor), + (Data.ProtoLens.Tag 4, messageType__field_descriptor), + (Data.ProtoLens.Tag 5, enumType__field_descriptor), + (Data.ProtoLens.Tag 6, service__field_descriptor), + (Data.ProtoLens.Tag 7, extension__field_descriptor), + (Data.ProtoLens.Tag 8, options__field_descriptor), + (Data.ProtoLens.Tag 9, sourceCodeInfo__field_descriptor), + (Data.ProtoLens.Tag 12, syntax__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _FileDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_FileDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.file' @:: Lens' FileDescriptorSet [FileDescriptorProto]@ + -} +data FileDescriptorSet = FileDescriptorSet{_FileDescriptorSet'file + :: ![FileDescriptorProto], + _FileDescriptorSet'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f FileDescriptorSet x a, a ~ b) => + Lens.Labels.HasLens f FileDescriptorSet FileDescriptorSet x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileDescriptorSet "file" + ([FileDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileDescriptorSet'file + (\ x__ y__ -> x__{_FileDescriptorSet'file = y__})) + Prelude.id +instance Data.Default.Class.Default FileDescriptorSet where + def + = FileDescriptorSet{_FileDescriptorSet'file = [], + _FileDescriptorSet'_unknownFields = ([])} +instance Data.ProtoLens.Message FileDescriptorSet where + messageName _ = Data.Text.pack "google.protobuf.FileDescriptorSet" + fieldsByTag + = let file__field_descriptor + = Data.ProtoLens.FieldDescriptor "file" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FileDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file"))) + :: Data.ProtoLens.FieldDescriptor FileDescriptorSet + in + Data.Map.fromList [(Data.ProtoLens.Tag 1, file__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _FileDescriptorSet'_unknownFields + (\ x__ y__ -> x__{_FileDescriptorSet'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.javaPackage' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.javaOuterClassname' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaOuterClassname' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.javaMultipleFiles' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaMultipleFiles' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenerateEqualsAndHash' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenerateEqualsAndHash' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.javaStringCheckUtf8' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaStringCheckUtf8' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.optimizeFor' @:: Lens' FileOptions FileOptions'OptimizeMode@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'optimizeFor' @:: Lens' FileOptions (Prelude.Maybe FileOptions'OptimizeMode)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.goPackage' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'goPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.ccGenericServices' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenericServices' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.pyGenericServices' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'pyGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.ccEnableArenas' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccEnableArenas' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.objcClassPrefix' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'objcClassPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.csharpNamespace' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'csharpNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FileOptions [UninterpretedOption]@ + -} +data FileOptions = FileOptions{_FileOptions'javaPackage :: + !(Prelude.Maybe Data.Text.Text), + _FileOptions'javaOuterClassname :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'javaMultipleFiles :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'javaGenerateEqualsAndHash :: + !(Prelude.Maybe Prelude.Bool), + _FileOptions'javaStringCheckUtf8 :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'optimizeFor :: + !(Prelude.Maybe FileOptions'OptimizeMode), + _FileOptions'goPackage :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'ccGenericServices :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'javaGenericServices :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'pyGenericServices :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'ccEnableArenas :: !(Prelude.Maybe Prelude.Bool), + _FileOptions'objcClassPrefix :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'csharpNamespace :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'uninterpretedOption :: ![UninterpretedOption], + _FileOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f FileOptions x a, a ~ b) => + Lens.Labels.HasLens f FileOptions FileOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaPackage" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaPackage + (\ x__ y__ -> x__{_FileOptions'javaPackage = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'javaPackage" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaPackage + (\ x__ y__ -> x__{_FileOptions'javaPackage = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaOuterClassname" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaOuterClassname + (\ x__ y__ -> x__{_FileOptions'javaOuterClassname = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'javaOuterClassname" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaOuterClassname + (\ x__ y__ -> x__{_FileOptions'javaOuterClassname = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaMultipleFiles" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaMultipleFiles + (\ x__ y__ -> x__{_FileOptions'javaMultipleFiles = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'javaMultipleFiles" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaMultipleFiles + (\ x__ y__ -> x__{_FileOptions'javaMultipleFiles = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaGenerateEqualsAndHash" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaGenerateEqualsAndHash + (\ x__ y__ -> x__{_FileOptions'javaGenerateEqualsAndHash = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions + "maybe'javaGenerateEqualsAndHash" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaGenerateEqualsAndHash + (\ x__ y__ -> x__{_FileOptions'javaGenerateEqualsAndHash = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaStringCheckUtf8" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaStringCheckUtf8 + (\ x__ y__ -> x__{_FileOptions'javaStringCheckUtf8 = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'javaStringCheckUtf8" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaStringCheckUtf8 + (\ x__ y__ -> x__{_FileOptions'javaStringCheckUtf8 = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "optimizeFor" + (FileOptions'OptimizeMode) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'optimizeFor + (\ x__ y__ -> x__{_FileOptions'optimizeFor = y__})) + (Data.ProtoLens.maybeLens FileOptions'SPEED) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'optimizeFor" + (Prelude.Maybe FileOptions'OptimizeMode) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'optimizeFor + (\ x__ y__ -> x__{_FileOptions'optimizeFor = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "goPackage" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'goPackage + (\ x__ y__ -> x__{_FileOptions'goPackage = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'goPackage" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'goPackage + (\ x__ y__ -> x__{_FileOptions'goPackage = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "ccGenericServices" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'ccGenericServices + (\ x__ y__ -> x__{_FileOptions'ccGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'ccGenericServices" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'ccGenericServices + (\ x__ y__ -> x__{_FileOptions'ccGenericServices = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "javaGenericServices" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaGenericServices + (\ x__ y__ -> x__{_FileOptions'javaGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'javaGenericServices" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'javaGenericServices + (\ x__ y__ -> x__{_FileOptions'javaGenericServices = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "pyGenericServices" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'pyGenericServices + (\ x__ y__ -> x__{_FileOptions'pyGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'pyGenericServices" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'pyGenericServices + (\ x__ y__ -> x__{_FileOptions'pyGenericServices = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'deprecated + (\ x__ y__ -> x__{_FileOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'deprecated + (\ x__ y__ -> x__{_FileOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "ccEnableArenas" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'ccEnableArenas + (\ x__ y__ -> x__{_FileOptions'ccEnableArenas = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'ccEnableArenas" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'ccEnableArenas + (\ x__ y__ -> x__{_FileOptions'ccEnableArenas = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "objcClassPrefix" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'objcClassPrefix + (\ x__ y__ -> x__{_FileOptions'objcClassPrefix = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'objcClassPrefix" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'objcClassPrefix + (\ x__ y__ -> x__{_FileOptions'objcClassPrefix = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "csharpNamespace" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'csharpNamespace + (\ x__ y__ -> x__{_FileOptions'csharpNamespace = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "maybe'csharpNamespace" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'csharpNamespace + (\ x__ y__ -> x__{_FileOptions'csharpNamespace = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f FileOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _FileOptions'uninterpretedOption + (\ x__ y__ -> x__{_FileOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default FileOptions where + def + = FileOptions{_FileOptions'javaPackage = Prelude.Nothing, + _FileOptions'javaOuterClassname = Prelude.Nothing, + _FileOptions'javaMultipleFiles = Prelude.Nothing, + _FileOptions'javaGenerateEqualsAndHash = Prelude.Nothing, + _FileOptions'javaStringCheckUtf8 = Prelude.Nothing, + _FileOptions'optimizeFor = Prelude.Nothing, + _FileOptions'goPackage = Prelude.Nothing, + _FileOptions'ccGenericServices = Prelude.Nothing, + _FileOptions'javaGenericServices = Prelude.Nothing, + _FileOptions'pyGenericServices = Prelude.Nothing, + _FileOptions'deprecated = Prelude.Nothing, + _FileOptions'ccEnableArenas = Prelude.Nothing, + _FileOptions'objcClassPrefix = Prelude.Nothing, + _FileOptions'csharpNamespace = Prelude.Nothing, + _FileOptions'uninterpretedOption = [], + _FileOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message FileOptions where + messageName _ = Data.Text.pack "google.protobuf.FileOptions" + fieldsByTag + = let javaPackage__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_package" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaPackage"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + javaOuterClassname__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_outer_classname" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaOuterClassname"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + javaMultipleFiles__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_multiple_files" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaMultipleFiles"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + javaGenerateEqualsAndHash__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_generate_equals_and_hash" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaGenerateEqualsAndHash"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + javaStringCheckUtf8__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_string_check_utf8" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaStringCheckUtf8"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + optimizeFor__field_descriptor + = Data.ProtoLens.FieldDescriptor "optimize_for" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FileOptions'OptimizeMode) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'optimizeFor"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + goPackage__field_descriptor + = Data.ProtoLens.FieldDescriptor "go_package" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'goPackage"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + ccGenericServices__field_descriptor + = Data.ProtoLens.FieldDescriptor "cc_generic_services" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'ccGenericServices"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + javaGenericServices__field_descriptor + = Data.ProtoLens.FieldDescriptor "java_generic_services" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaGenericServices"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + pyGenericServices__field_descriptor + = Data.ProtoLens.FieldDescriptor "py_generic_services" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'pyGenericServices"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + ccEnableArenas__field_descriptor + = Data.ProtoLens.FieldDescriptor "cc_enable_arenas" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'ccEnableArenas"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + objcClassPrefix__field_descriptor + = Data.ProtoLens.FieldDescriptor "objc_class_prefix" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'objcClassPrefix"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + csharpNamespace__field_descriptor + = Data.ProtoLens.FieldDescriptor "csharp_namespace" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'csharpNamespace"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor FileOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, javaPackage__field_descriptor), + (Data.ProtoLens.Tag 8, javaOuterClassname__field_descriptor), + (Data.ProtoLens.Tag 10, javaMultipleFiles__field_descriptor), + (Data.ProtoLens.Tag 20, + javaGenerateEqualsAndHash__field_descriptor), + (Data.ProtoLens.Tag 27, javaStringCheckUtf8__field_descriptor), + (Data.ProtoLens.Tag 9, optimizeFor__field_descriptor), + (Data.ProtoLens.Tag 11, goPackage__field_descriptor), + (Data.ProtoLens.Tag 16, ccGenericServices__field_descriptor), + (Data.ProtoLens.Tag 17, javaGenericServices__field_descriptor), + (Data.ProtoLens.Tag 18, pyGenericServices__field_descriptor), + (Data.ProtoLens.Tag 23, deprecated__field_descriptor), + (Data.ProtoLens.Tag 31, ccEnableArenas__field_descriptor), + (Data.ProtoLens.Tag 36, objcClassPrefix__field_descriptor), + (Data.ProtoLens.Tag 37, csharpNamespace__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _FileOptions'_unknownFields + (\ x__ y__ -> x__{_FileOptions'_unknownFields = y__}) +data FileOptions'OptimizeMode = FileOptions'SPEED + | FileOptions'CODE_SIZE + | FileOptions'LITE_RUNTIME + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.Default.Class.Default FileOptions'OptimizeMode where + def = FileOptions'SPEED +instance Data.ProtoLens.FieldDefault FileOptions'OptimizeMode where + fieldDefault = FileOptions'SPEED +instance Data.ProtoLens.MessageEnum FileOptions'OptimizeMode where + maybeToEnum 1 = Prelude.Just FileOptions'SPEED + maybeToEnum 2 = Prelude.Just FileOptions'CODE_SIZE + maybeToEnum 3 = Prelude.Just FileOptions'LITE_RUNTIME + maybeToEnum _ = Prelude.Nothing + showEnum FileOptions'SPEED = "SPEED" + showEnum FileOptions'CODE_SIZE = "CODE_SIZE" + showEnum FileOptions'LITE_RUNTIME = "LITE_RUNTIME" + readEnum "SPEED" = Prelude.Just FileOptions'SPEED + readEnum "CODE_SIZE" = Prelude.Just FileOptions'CODE_SIZE + readEnum "LITE_RUNTIME" = Prelude.Just FileOptions'LITE_RUNTIME + readEnum _ = Prelude.Nothing +instance Prelude.Enum FileOptions'OptimizeMode where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) "toEnum: unknown value for enum OptimizeMode: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FileOptions'SPEED = 1 + fromEnum FileOptions'CODE_SIZE = 2 + fromEnum FileOptions'LITE_RUNTIME = 3 + succ FileOptions'LITE_RUNTIME + = Prelude.error + "FileOptions'OptimizeMode.succ: bad argument FileOptions'LITE_RUNTIME. This value would be out of bounds." + succ FileOptions'SPEED = FileOptions'CODE_SIZE + succ FileOptions'CODE_SIZE = FileOptions'LITE_RUNTIME + pred FileOptions'SPEED + = Prelude.error + "FileOptions'OptimizeMode.pred: bad argument FileOptions'SPEED. This value would be out of bounds." + pred FileOptions'CODE_SIZE = FileOptions'SPEED + pred FileOptions'LITE_RUNTIME = FileOptions'CODE_SIZE + enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom + enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo + enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen + enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo +instance Prelude.Bounded FileOptions'OptimizeMode where + minBound = FileOptions'SPEED + maxBound = FileOptions'LITE_RUNTIME +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.annotation' @:: Lens' GeneratedCodeInfo [GeneratedCodeInfo'Annotation]@ + -} +data GeneratedCodeInfo = GeneratedCodeInfo{_GeneratedCodeInfo'annotation + :: ![GeneratedCodeInfo'Annotation], + _GeneratedCodeInfo'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f GeneratedCodeInfo x a, a ~ b) => + Lens.Labels.HasLens f GeneratedCodeInfo GeneratedCodeInfo x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo "annotation" + ([GeneratedCodeInfo'Annotation]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'annotation + (\ x__ y__ -> x__{_GeneratedCodeInfo'annotation = y__})) + Prelude.id +instance Data.Default.Class.Default GeneratedCodeInfo where + def + = GeneratedCodeInfo{_GeneratedCodeInfo'annotation = [], + _GeneratedCodeInfo'_unknownFields = ([])} +instance Data.ProtoLens.Message GeneratedCodeInfo where + messageName _ = Data.Text.pack "google.protobuf.GeneratedCodeInfo" + fieldsByTag + = let annotation__field_descriptor + = Data.ProtoLens.FieldDescriptor "annotation" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor GeneratedCodeInfo'Annotation) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "annotation"))) + :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, annotation__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _GeneratedCodeInfo'_unknownFields + (\ x__ y__ -> x__{_GeneratedCodeInfo'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' GeneratedCodeInfo'Annotation [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.sourceFile' @:: Lens' GeneratedCodeInfo'Annotation Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceFile' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.begin' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'begin' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@ + -} +data GeneratedCodeInfo'Annotation = GeneratedCodeInfo'Annotation{_GeneratedCodeInfo'Annotation'path + :: ![Data.Int.Int32], + _GeneratedCodeInfo'Annotation'sourceFile + :: !(Prelude.Maybe Data.Text.Text), + _GeneratedCodeInfo'Annotation'begin + :: !(Prelude.Maybe Data.Int.Int32), + _GeneratedCodeInfo'Annotation'end + :: !(Prelude.Maybe Data.Int.Int32), + _GeneratedCodeInfo'Annotation'_unknownFields + :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation x a, + a ~ b) => + Lens.Labels.HasLens f GeneratedCodeInfo'Annotation + GeneratedCodeInfo'Annotation + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "path" + ([Data.Int.Int32]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'path + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'path = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "sourceFile" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'sourceFile + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'sourceFile = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation + "maybe'sourceFile" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'sourceFile + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'sourceFile = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "begin" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'begin + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'begin = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "maybe'begin" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'begin + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'begin = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "end" + (Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'end + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "maybe'end" + (Prelude.Maybe Data.Int.Int32) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'end + (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'end = y__})) + Prelude.id +instance Data.Default.Class.Default GeneratedCodeInfo'Annotation + where + def + = GeneratedCodeInfo'Annotation{_GeneratedCodeInfo'Annotation'path = + [], + _GeneratedCodeInfo'Annotation'sourceFile = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'begin = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'end = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'_unknownFields = ([])} +instance Data.ProtoLens.Message GeneratedCodeInfo'Annotation where + messageName _ + = Data.Text.pack "google.protobuf.GeneratedCodeInfo.Annotation" + fieldsByTag + = let path__field_descriptor + = Data.ProtoLens.FieldDescriptor "path" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path"))) + :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation + sourceFile__field_descriptor + = Data.ProtoLens.FieldDescriptor "source_file" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'sourceFile"))) + :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation + begin__field_descriptor + = Data.ProtoLens.FieldDescriptor "begin" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'begin"))) + :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation + end__field_descriptor + = Data.ProtoLens.FieldDescriptor "end" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end"))) + :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, path__field_descriptor), + (Data.ProtoLens.Tag 2, sourceFile__field_descriptor), + (Data.ProtoLens.Tag 3, begin__field_descriptor), + (Data.ProtoLens.Tag 4, end__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'_unknownFields + (\ x__ y__ -> + x__{_GeneratedCodeInfo'Annotation'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.messageSetWireFormat' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'messageSetWireFormat' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.noStandardDescriptorAccessor' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'noStandardDescriptorAccessor' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.mapEntry' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'mapEntry' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MessageOptions [UninterpretedOption]@ + -} +data MessageOptions = MessageOptions{_MessageOptions'messageSetWireFormat + :: !(Prelude.Maybe Prelude.Bool), + _MessageOptions'noStandardDescriptorAccessor :: + !(Prelude.Maybe Prelude.Bool), + _MessageOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _MessageOptions'mapEntry :: !(Prelude.Maybe Prelude.Bool), + _MessageOptions'uninterpretedOption :: ![UninterpretedOption], + _MessageOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f MessageOptions x a, a ~ b) => + Lens.Labels.HasLens f MessageOptions MessageOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "messageSetWireFormat" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'messageSetWireFormat + (\ x__ y__ -> x__{_MessageOptions'messageSetWireFormat = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "maybe'messageSetWireFormat" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'messageSetWireFormat + (\ x__ y__ -> x__{_MessageOptions'messageSetWireFormat = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions + "noStandardDescriptorAccessor" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'noStandardDescriptorAccessor + (\ x__ y__ -> + x__{_MessageOptions'noStandardDescriptorAccessor = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions + "maybe'noStandardDescriptorAccessor" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'noStandardDescriptorAccessor + (\ x__ y__ -> + x__{_MessageOptions'noStandardDescriptorAccessor = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'deprecated + (\ x__ y__ -> x__{_MessageOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'deprecated + (\ x__ y__ -> x__{_MessageOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "mapEntry" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'mapEntry + (\ x__ y__ -> x__{_MessageOptions'mapEntry = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "maybe'mapEntry" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'mapEntry + (\ x__ y__ -> x__{_MessageOptions'mapEntry = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MessageOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MessageOptions'uninterpretedOption + (\ x__ y__ -> x__{_MessageOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default MessageOptions where + def + = MessageOptions{_MessageOptions'messageSetWireFormat = + Prelude.Nothing, + _MessageOptions'noStandardDescriptorAccessor = Prelude.Nothing, + _MessageOptions'deprecated = Prelude.Nothing, + _MessageOptions'mapEntry = Prelude.Nothing, + _MessageOptions'uninterpretedOption = [], + _MessageOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message MessageOptions where + messageName _ = Data.Text.pack "google.protobuf.MessageOptions" + fieldsByTag + = let messageSetWireFormat__field_descriptor + = Data.ProtoLens.FieldDescriptor "message_set_wire_format" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'messageSetWireFormat"))) + :: Data.ProtoLens.FieldDescriptor MessageOptions + noStandardDescriptorAccessor__field_descriptor + = Data.ProtoLens.FieldDescriptor "no_standard_descriptor_accessor" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'noStandardDescriptorAccessor"))) + :: Data.ProtoLens.FieldDescriptor MessageOptions + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor MessageOptions + mapEntry__field_descriptor + = Data.ProtoLens.FieldDescriptor "map_entry" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'mapEntry"))) + :: Data.ProtoLens.FieldDescriptor MessageOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor MessageOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, messageSetWireFormat__field_descriptor), + (Data.ProtoLens.Tag 2, + noStandardDescriptorAccessor__field_descriptor), + (Data.ProtoLens.Tag 3, deprecated__field_descriptor), + (Data.ProtoLens.Tag 7, mapEntry__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _MessageOptions'_unknownFields + (\ x__ y__ -> x__{_MessageOptions'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' MethodDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.inputType' @:: Lens' MethodDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'inputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.outputType' @:: Lens' MethodDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'outputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' MethodDescriptorProto MethodOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' MethodDescriptorProto (Prelude.Maybe MethodOptions)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.clientStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'clientStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.serverStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'serverStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@ + -} +data MethodDescriptorProto = MethodDescriptorProto{_MethodDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _MethodDescriptorProto'inputType :: + !(Prelude.Maybe Data.Text.Text), + _MethodDescriptorProto'outputType :: + !(Prelude.Maybe Data.Text.Text), + _MethodDescriptorProto'options :: + !(Prelude.Maybe MethodOptions), + _MethodDescriptorProto'clientStreaming :: + !(Prelude.Maybe Prelude.Bool), + _MethodDescriptorProto'serverStreaming :: + !(Prelude.Maybe Prelude.Bool), + _MethodDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f MethodDescriptorProto x a, + a ~ b) => + Lens.Labels.HasLens f MethodDescriptorProto MethodDescriptorProto x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "name" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'name + (\ x__ y__ -> x__{_MethodDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'name + (\ x__ y__ -> x__{_MethodDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "inputType" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'inputType + (\ x__ y__ -> x__{_MethodDescriptorProto'inputType = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "maybe'inputType" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'inputType + (\ x__ y__ -> x__{_MethodDescriptorProto'inputType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "outputType" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'outputType + (\ x__ y__ -> x__{_MethodDescriptorProto'outputType = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "maybe'outputType" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'outputType + (\ x__ y__ -> x__{_MethodDescriptorProto'outputType = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "options" + (MethodOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'options + (\ x__ y__ -> x__{_MethodDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "maybe'options" + (Prelude.Maybe MethodOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'options + (\ x__ y__ -> x__{_MethodDescriptorProto'options = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "clientStreaming" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'clientStreaming + (\ x__ y__ -> x__{_MethodDescriptorProto'clientStreaming = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto + "maybe'clientStreaming" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'clientStreaming + (\ x__ y__ -> x__{_MethodDescriptorProto'clientStreaming = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto "serverStreaming" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'serverStreaming + (\ x__ y__ -> x__{_MethodDescriptorProto'serverStreaming = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodDescriptorProto + "maybe'serverStreaming" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodDescriptorProto'serverStreaming + (\ x__ y__ -> x__{_MethodDescriptorProto'serverStreaming = y__})) + Prelude.id +instance Data.Default.Class.Default MethodDescriptorProto where + def + = MethodDescriptorProto{_MethodDescriptorProto'name = + Prelude.Nothing, + _MethodDescriptorProto'inputType = Prelude.Nothing, + _MethodDescriptorProto'outputType = Prelude.Nothing, + _MethodDescriptorProto'options = Prelude.Nothing, + _MethodDescriptorProto'clientStreaming = Prelude.Nothing, + _MethodDescriptorProto'serverStreaming = Prelude.Nothing, + _MethodDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message MethodDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.MethodDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + inputType__field_descriptor + = Data.ProtoLens.FieldDescriptor "input_type" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'inputType"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + outputType__field_descriptor + = Data.ProtoLens.FieldDescriptor "output_type" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'outputType"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor MethodOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + clientStreaming__field_descriptor + = Data.ProtoLens.FieldDescriptor "client_streaming" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'clientStreaming"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + serverStreaming__field_descriptor + = Data.ProtoLens.FieldDescriptor "server_streaming" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'serverStreaming"))) + :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, inputType__field_descriptor), + (Data.ProtoLens.Tag 3, outputType__field_descriptor), + (Data.ProtoLens.Tag 4, options__field_descriptor), + (Data.ProtoLens.Tag 5, clientStreaming__field_descriptor), + (Data.ProtoLens.Tag 6, serverStreaming__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _MethodDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_MethodDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MethodOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MethodOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MethodOptions [UninterpretedOption]@ + -} +data MethodOptions = MethodOptions{_MethodOptions'deprecated :: + !(Prelude.Maybe Prelude.Bool), + _MethodOptions'uninterpretedOption :: ![UninterpretedOption], + _MethodOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f MethodOptions x a, a ~ b) => + Lens.Labels.HasLens f MethodOptions MethodOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodOptions'deprecated + (\ x__ y__ -> x__{_MethodOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodOptions'deprecated + (\ x__ y__ -> x__{_MethodOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f MethodOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _MethodOptions'uninterpretedOption + (\ x__ y__ -> x__{_MethodOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default MethodOptions where + def + = MethodOptions{_MethodOptions'deprecated = Prelude.Nothing, + _MethodOptions'uninterpretedOption = [], + _MethodOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message MethodOptions where + messageName _ = Data.Text.pack "google.protobuf.MethodOptions" + fieldsByTag + = let deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor MethodOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor MethodOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 33, deprecated__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _MethodOptions'_unknownFields + (\ x__ y__ -> x__{_MethodOptions'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' OneofDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' OneofDescriptorProto (Prelude.Maybe Data.Text.Text)@ + -} +data OneofDescriptorProto = OneofDescriptorProto{_OneofDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _OneofDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f OneofDescriptorProto x a, + a ~ b) => + Lens.Labels.HasLens f OneofDescriptorProto OneofDescriptorProto x a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f OneofDescriptorProto "name" (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _OneofDescriptorProto'name + (\ x__ y__ -> x__{_OneofDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f OneofDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _OneofDescriptorProto'name + (\ x__ y__ -> x__{_OneofDescriptorProto'name = y__})) + Prelude.id +instance Data.Default.Class.Default OneofDescriptorProto where + def + = OneofDescriptorProto{_OneofDescriptorProto'name = + Prelude.Nothing, + _OneofDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message OneofDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.OneofDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor OneofDescriptorProto + in + Data.Map.fromList [(Data.ProtoLens.Tag 1, name__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _OneofDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_OneofDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' ServiceDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' ServiceDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.method' @:: Lens' ServiceDescriptorProto [MethodDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' ServiceDescriptorProto ServiceOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' ServiceDescriptorProto (Prelude.Maybe ServiceOptions)@ + -} +data ServiceDescriptorProto = ServiceDescriptorProto{_ServiceDescriptorProto'name + :: !(Prelude.Maybe Data.Text.Text), + _ServiceDescriptorProto'method :: + ![MethodDescriptorProto], + _ServiceDescriptorProto'options :: + !(Prelude.Maybe ServiceOptions), + _ServiceDescriptorProto'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f ServiceDescriptorProto x a, + a ~ b) => + Lens.Labels.HasLens f ServiceDescriptorProto ServiceDescriptorProto + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceDescriptorProto "name" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'name + (\ x__ y__ -> x__{_ServiceDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceDescriptorProto "maybe'name" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'name + (\ x__ y__ -> x__{_ServiceDescriptorProto'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceDescriptorProto "method" + ([MethodDescriptorProto]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'method + (\ x__ y__ -> x__{_ServiceDescriptorProto'method = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceDescriptorProto "options" + (ServiceOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'options + (\ x__ y__ -> x__{_ServiceDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.Default.Class.def) +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceDescriptorProto "maybe'options" + (Prelude.Maybe ServiceOptions) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'options + (\ x__ y__ -> x__{_ServiceDescriptorProto'options = y__})) + Prelude.id +instance Data.Default.Class.Default ServiceDescriptorProto where + def + = ServiceDescriptorProto{_ServiceDescriptorProto'name = + Prelude.Nothing, + _ServiceDescriptorProto'method = [], + _ServiceDescriptorProto'options = Prelude.Nothing, + _ServiceDescriptorProto'_unknownFields = ([])} +instance Data.ProtoLens.Message ServiceDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.ServiceDescriptorProto" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name"))) + :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto + method__field_descriptor + = Data.ProtoLens.FieldDescriptor "method" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor MethodDescriptorProto) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "method"))) + :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor ServiceOptions) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options"))) + :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, method__field_descriptor), + (Data.ProtoLens.Tag 3, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'_unknownFields + (\ x__ y__ -> x__{_ServiceDescriptorProto'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' ServiceOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' ServiceOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ServiceOptions [UninterpretedOption]@ + -} +data ServiceOptions = ServiceOptions{_ServiceOptions'deprecated :: + !(Prelude.Maybe Prelude.Bool), + _ServiceOptions'uninterpretedOption :: ![UninterpretedOption], + _ServiceOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f ServiceOptions x a, a ~ b) => + Lens.Labels.HasLens f ServiceOptions ServiceOptions x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceOptions "deprecated" (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceOptions'deprecated + (\ x__ y__ -> x__{_ServiceOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceOptions "maybe'deprecated" + (Prelude.Maybe Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceOptions'deprecated + (\ x__ y__ -> x__{_ServiceOptions'deprecated = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f ServiceOptions "uninterpretedOption" + ([UninterpretedOption]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _ServiceOptions'uninterpretedOption + (\ x__ y__ -> x__{_ServiceOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.Default.Class.Default ServiceOptions where + def + = ServiceOptions{_ServiceOptions'deprecated = Prelude.Nothing, + _ServiceOptions'uninterpretedOption = [], + _ServiceOptions'_unknownFields = ([])} +instance Data.ProtoLens.Message ServiceOptions where + messageName _ = Data.Text.pack "google.protobuf.ServiceOptions" + fieldsByTag + = let deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated"))) + :: Data.ProtoLens.FieldDescriptor ServiceOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption"))) + :: Data.ProtoLens.FieldDescriptor ServiceOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 33, deprecated__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _ServiceOptions'_unknownFields + (\ x__ y__ -> x__{_ServiceOptions'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.location' @:: Lens' SourceCodeInfo [SourceCodeInfo'Location]@ + -} +data SourceCodeInfo = SourceCodeInfo{_SourceCodeInfo'location :: + ![SourceCodeInfo'Location], + _SourceCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f SourceCodeInfo x a, a ~ b) => + Lens.Labels.HasLens f SourceCodeInfo SourceCodeInfo x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo "location" + ([SourceCodeInfo'Location]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _SourceCodeInfo'location + (\ x__ y__ -> x__{_SourceCodeInfo'location = y__})) + Prelude.id +instance Data.Default.Class.Default SourceCodeInfo where + def + = SourceCodeInfo{_SourceCodeInfo'location = [], + _SourceCodeInfo'_unknownFields = ([])} +instance Data.ProtoLens.Message SourceCodeInfo where + messageName _ = Data.Text.pack "google.protobuf.SourceCodeInfo" + fieldsByTag + = let location__field_descriptor + = Data.ProtoLens.FieldDescriptor "location" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo'Location) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "location"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, location__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _SourceCodeInfo'_unknownFields + (\ x__ y__ -> x__{_SourceCodeInfo'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.span' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.leadingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'leadingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.trailingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'trailingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.leadingDetachedComments' @:: Lens' SourceCodeInfo'Location [Data.Text.Text]@ + -} +data SourceCodeInfo'Location = SourceCodeInfo'Location{_SourceCodeInfo'Location'path + :: ![Data.Int.Int32], + _SourceCodeInfo'Location'span :: + ![Data.Int.Int32], + _SourceCodeInfo'Location'leadingComments :: + !(Prelude.Maybe Data.Text.Text), + _SourceCodeInfo'Location'trailingComments :: + !(Prelude.Maybe Data.Text.Text), + _SourceCodeInfo'Location'leadingDetachedComments + :: ![Data.Text.Text], + _SourceCodeInfo'Location'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f SourceCodeInfo'Location x a, + a ~ b) => + Lens.Labels.HasLens f SourceCodeInfo'Location + SourceCodeInfo'Location + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location "path" + ([Data.Int.Int32]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _SourceCodeInfo'Location'path + (\ x__ y__ -> x__{_SourceCodeInfo'Location'path = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location "span" + ([Data.Int.Int32]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _SourceCodeInfo'Location'span + (\ x__ y__ -> x__{_SourceCodeInfo'Location'span = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location "leadingComments" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingComments + (\ x__ y__ -> x__{_SourceCodeInfo'Location'leadingComments = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location + "maybe'leadingComments" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingComments + (\ x__ y__ -> x__{_SourceCodeInfo'Location'leadingComments = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location "trailingComments" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'trailingComments + (\ x__ y__ -> + x__{_SourceCodeInfo'Location'trailingComments = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location + "maybe'trailingComments" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'trailingComments + (\ x__ y__ -> + x__{_SourceCodeInfo'Location'trailingComments = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f SourceCodeInfo'Location + "leadingDetachedComments" + ([Data.Text.Text]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingDetachedComments + (\ x__ y__ -> + x__{_SourceCodeInfo'Location'leadingDetachedComments = y__})) + Prelude.id +instance Data.Default.Class.Default SourceCodeInfo'Location where + def + = SourceCodeInfo'Location{_SourceCodeInfo'Location'path = [], + _SourceCodeInfo'Location'span = [], + _SourceCodeInfo'Location'leadingComments = Prelude.Nothing, + _SourceCodeInfo'Location'trailingComments = Prelude.Nothing, + _SourceCodeInfo'Location'leadingDetachedComments = [], + _SourceCodeInfo'Location'_unknownFields = ([])} +instance Data.ProtoLens.Message SourceCodeInfo'Location where + messageName _ + = Data.Text.pack "google.protobuf.SourceCodeInfo.Location" + fieldsByTag + = let path__field_descriptor + = Data.ProtoLens.FieldDescriptor "path" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location + span__field_descriptor + = Data.ProtoLens.FieldDescriptor "span" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "span"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location + leadingComments__field_descriptor + = Data.ProtoLens.FieldDescriptor "leading_comments" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'leadingComments"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location + trailingComments__field_descriptor + = Data.ProtoLens.FieldDescriptor "trailing_comments" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'trailingComments"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location + leadingDetachedComments__field_descriptor + = Data.ProtoLens.FieldDescriptor "leading_detached_comments" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "leadingDetachedComments"))) + :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, path__field_descriptor), + (Data.ProtoLens.Tag 2, span__field_descriptor), + (Data.ProtoLens.Tag 3, leadingComments__field_descriptor), + (Data.ProtoLens.Tag 4, trailingComments__field_descriptor), + (Data.ProtoLens.Tag 6, leadingDetachedComments__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'_unknownFields + (\ x__ y__ -> x__{_SourceCodeInfo'Location'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' UninterpretedOption [UninterpretedOption'NamePart]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.identifierValue' @:: Lens' UninterpretedOption Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'identifierValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.positiveIntValue' @:: Lens' UninterpretedOption Data.Word.Word64@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'positiveIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Word.Word64)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.negativeIntValue' @:: Lens' UninterpretedOption Data.Int.Int64@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'negativeIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Int.Int64)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.doubleValue' @:: Lens' UninterpretedOption Prelude.Double@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'doubleValue' @:: Lens' UninterpretedOption (Prelude.Maybe Prelude.Double)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.stringValue' @:: Lens' UninterpretedOption Data.ByteString.ByteString@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'stringValue' @:: Lens' UninterpretedOption + (Prelude.Maybe Data.ByteString.ByteString)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.aggregateValue' @:: Lens' UninterpretedOption Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'aggregateValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@ + -} +data UninterpretedOption = UninterpretedOption{_UninterpretedOption'name + :: ![UninterpretedOption'NamePart], + _UninterpretedOption'identifierValue :: + !(Prelude.Maybe Data.Text.Text), + _UninterpretedOption'positiveIntValue :: + !(Prelude.Maybe Data.Word.Word64), + _UninterpretedOption'negativeIntValue :: + !(Prelude.Maybe Data.Int.Int64), + _UninterpretedOption'doubleValue :: + !(Prelude.Maybe Prelude.Double), + _UninterpretedOption'stringValue :: + !(Prelude.Maybe Data.ByteString.ByteString), + _UninterpretedOption'aggregateValue :: + !(Prelude.Maybe Data.Text.Text), + _UninterpretedOption'_unknownFields :: + !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f UninterpretedOption x a, a ~ b) => + Lens.Labels.HasLens f UninterpretedOption UninterpretedOption x a b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "name" + ([UninterpretedOption'NamePart]) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'name + (\ x__ y__ -> x__{_UninterpretedOption'name = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "identifierValue" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'identifierValue + (\ x__ y__ -> x__{_UninterpretedOption'identifierValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'identifierValue" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'identifierValue + (\ x__ y__ -> x__{_UninterpretedOption'identifierValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "positiveIntValue" + (Data.Word.Word64) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'positiveIntValue + (\ x__ y__ -> x__{_UninterpretedOption'positiveIntValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'positiveIntValue" + (Prelude.Maybe Data.Word.Word64) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'positiveIntValue + (\ x__ y__ -> x__{_UninterpretedOption'positiveIntValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "negativeIntValue" + (Data.Int.Int64) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'negativeIntValue + (\ x__ y__ -> x__{_UninterpretedOption'negativeIntValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'negativeIntValue" + (Prelude.Maybe Data.Int.Int64) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'negativeIntValue + (\ x__ y__ -> x__{_UninterpretedOption'negativeIntValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "doubleValue" + (Prelude.Double) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'doubleValue + (\ x__ y__ -> x__{_UninterpretedOption'doubleValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'doubleValue" + (Prelude.Maybe Prelude.Double) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'doubleValue + (\ x__ y__ -> x__{_UninterpretedOption'doubleValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "stringValue" + (Data.ByteString.ByteString) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'stringValue + (\ x__ y__ -> x__{_UninterpretedOption'stringValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'stringValue" + (Prelude.Maybe Data.ByteString.ByteString) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'stringValue + (\ x__ y__ -> x__{_UninterpretedOption'stringValue = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "aggregateValue" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'aggregateValue + (\ x__ y__ -> x__{_UninterpretedOption'aggregateValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption "maybe'aggregateValue" + (Prelude.Maybe Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'aggregateValue + (\ x__ y__ -> x__{_UninterpretedOption'aggregateValue = y__})) + Prelude.id +instance Data.Default.Class.Default UninterpretedOption where + def + = UninterpretedOption{_UninterpretedOption'name = [], + _UninterpretedOption'identifierValue = Prelude.Nothing, + _UninterpretedOption'positiveIntValue = Prelude.Nothing, + _UninterpretedOption'negativeIntValue = Prelude.Nothing, + _UninterpretedOption'doubleValue = Prelude.Nothing, + _UninterpretedOption'stringValue = Prelude.Nothing, + _UninterpretedOption'aggregateValue = Prelude.Nothing, + _UninterpretedOption'_unknownFields = ([])} +instance Data.ProtoLens.Message UninterpretedOption where + messageName _ + = Data.Text.pack "google.protobuf.UninterpretedOption" + fieldsByTag + = let name__field_descriptor + = Data.ProtoLens.FieldDescriptor "name" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption'NamePart) + (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + identifierValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "identifier_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'identifierValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + positiveIntValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "positive_int_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'positiveIntValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + negativeIntValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "negative_int_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'negativeIntValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + doubleValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "double_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.DoubleField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Double) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'doubleValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + stringValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "string_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField :: + Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'stringValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + aggregateValue__field_descriptor + = Data.ProtoLens.FieldDescriptor "aggregate_value" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'aggregateValue"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption + in + Data.Map.fromList + [(Data.ProtoLens.Tag 2, name__field_descriptor), + (Data.ProtoLens.Tag 3, identifierValue__field_descriptor), + (Data.ProtoLens.Tag 4, positiveIntValue__field_descriptor), + (Data.ProtoLens.Tag 5, negativeIntValue__field_descriptor), + (Data.ProtoLens.Tag 6, doubleValue__field_descriptor), + (Data.ProtoLens.Tag 7, stringValue__field_descriptor), + (Data.ProtoLens.Tag 8, aggregateValue__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens _UninterpretedOption'_unknownFields + (\ x__ y__ -> x__{_UninterpretedOption'_unknownFields = y__}) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.namePart' @:: Lens' UninterpretedOption'NamePart Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.isExtension' @:: Lens' UninterpretedOption'NamePart Prelude.Bool@ + -} +data UninterpretedOption'NamePart = UninterpretedOption'NamePart{_UninterpretedOption'NamePart'namePart + :: !Data.Text.Text, + _UninterpretedOption'NamePart'isExtension + :: !Prelude.Bool, + _UninterpretedOption'NamePart'_unknownFields + :: !Data.ProtoLens.FieldSet} + deriving (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance (Lens.Labels.HasLens' f UninterpretedOption'NamePart x a, + a ~ b) => + Lens.Labels.HasLens f UninterpretedOption'NamePart + UninterpretedOption'NamePart + x + a + b + where + lensOf = Lens.Labels.lensOf' +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption'NamePart "namePart" + (Data.Text.Text) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens _UninterpretedOption'NamePart'namePart + (\ x__ y__ -> x__{_UninterpretedOption'NamePart'namePart = y__})) + Prelude.id +instance Prelude.Functor f => + Lens.Labels.HasLens' f UninterpretedOption'NamePart "isExtension" + (Prelude.Bool) + where + lensOf' _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'NamePart'isExtension + (\ x__ y__ -> + x__{_UninterpretedOption'NamePart'isExtension = y__})) + Prelude.id +instance Data.Default.Class.Default UninterpretedOption'NamePart + where + def + = UninterpretedOption'NamePart{_UninterpretedOption'NamePart'namePart + = Data.ProtoLens.fieldDefault, + _UninterpretedOption'NamePart'isExtension = + Data.ProtoLens.fieldDefault, + _UninterpretedOption'NamePart'_unknownFields = ([])} +instance Data.ProtoLens.Message UninterpretedOption'NamePart where + messageName _ + = Data.Text.pack "google.protobuf.UninterpretedOption.NamePart" + fieldsByTag + = let namePart__field_descriptor + = Data.ProtoLens.FieldDescriptor "name_part" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.PlainField Data.ProtoLens.Required + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "namePart"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart + isExtension__field_descriptor + = Data.ProtoLens.FieldDescriptor "is_extension" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.PlainField Data.ProtoLens.Required + (Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "isExtension"))) + :: Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, namePart__field_descriptor), + (Data.ProtoLens.Tag 2, isExtension__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _UninterpretedOption'NamePart'_unknownFields + (\ x__ y__ -> + x__{_UninterpretedOption'NamePart'_unknownFields = y__}) diff --git a/src/Proto/Google/Protobuf/Descriptor_Fields.hs b/src/Proto/Google/Protobuf/Descriptor_Fields.hs new file mode 100644 --- /dev/null +++ b/src/Proto/Google/Protobuf/Descriptor_Fields.hs @@ -0,0 +1,894 @@ +{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, GeneralizedNewtypeDeriving, + MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, + PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports#-} +module Proto.Google.Protobuf.Descriptor_Fields where +import qualified Prelude +import qualified Data.Int +import qualified Data.Word +import qualified Data.ProtoLens +import qualified Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Service.Types +import qualified Lens.Family2 +import qualified Lens.Family2.Unchecked +import qualified Data.Default.Class +import qualified Data.Text +import qualified Data.Map +import qualified Data.ByteString +import qualified Data.ByteString.Char8 +import qualified Lens.Labels +import qualified Text.Read + +aggregateValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "aggregateValue" a b) => + Lens.Family2.LensLike f s t a b +aggregateValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "aggregateValue") +allowAlias :: + forall f s t a b . (Lens.Labels.HasLens f s t "allowAlias" a b) => + Lens.Family2.LensLike f s t a b +allowAlias + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "allowAlias") +annotation :: + forall f s t a b . (Lens.Labels.HasLens f s t "annotation" a b) => + Lens.Family2.LensLike f s t a b +annotation + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "annotation") +begin :: + forall f s t a b . (Lens.Labels.HasLens f s t "begin" a b) => + Lens.Family2.LensLike f s t a b +begin + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "begin") +ccEnableArenas :: + forall f s t a b . + (Lens.Labels.HasLens f s t "ccEnableArenas" a b) => + Lens.Family2.LensLike f s t a b +ccEnableArenas + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ccEnableArenas") +ccGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "ccGenericServices" a b) => + Lens.Family2.LensLike f s t a b +ccGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ccGenericServices") +clientStreaming :: + forall f s t a b . + (Lens.Labels.HasLens f s t "clientStreaming" a b) => + Lens.Family2.LensLike f s t a b +clientStreaming + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "clientStreaming") +csharpNamespace :: + forall f s t a b . + (Lens.Labels.HasLens f s t "csharpNamespace" a b) => + Lens.Family2.LensLike f s t a b +csharpNamespace + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "csharpNamespace") +ctype :: + forall f s t a b . (Lens.Labels.HasLens f s t "ctype" a b) => + Lens.Family2.LensLike f s t a b +ctype + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ctype") +defaultValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "defaultValue" a b) => + Lens.Family2.LensLike f s t a b +defaultValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "defaultValue") +dependency :: + forall f s t a b . (Lens.Labels.HasLens f s t "dependency" a b) => + Lens.Family2.LensLike f s t a b +dependency + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "dependency") +deprecated :: + forall f s t a b . (Lens.Labels.HasLens f s t "deprecated" a b) => + Lens.Family2.LensLike f s t a b +deprecated + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "deprecated") +doubleValue :: + forall f s t a b . (Lens.Labels.HasLens f s t "doubleValue" a b) => + Lens.Family2.LensLike f s t a b +doubleValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "doubleValue") +end :: + forall f s t a b . (Lens.Labels.HasLens f s t "end" a b) => + Lens.Family2.LensLike f s t a b +end + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "end") +enumType :: + forall f s t a b . (Lens.Labels.HasLens f s t "enumType" a b) => + Lens.Family2.LensLike f s t a b +enumType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType") +extendee :: + forall f s t a b . (Lens.Labels.HasLens f s t "extendee" a b) => + Lens.Family2.LensLike f s t a b +extendee + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extendee") +extension :: + forall f s t a b . (Lens.Labels.HasLens f s t "extension" a b) => + Lens.Family2.LensLike f s t a b +extension + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension") +extensionRange :: + forall f s t a b . + (Lens.Labels.HasLens f s t "extensionRange" a b) => + Lens.Family2.LensLike f s t a b +extensionRange + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extensionRange") +field :: + forall f s t a b . (Lens.Labels.HasLens f s t "field" a b) => + Lens.Family2.LensLike f s t a b +field + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "field") +file :: + forall f s t a b . (Lens.Labels.HasLens f s t "file" a b) => + Lens.Family2.LensLike f s t a b +file + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file") +goPackage :: + forall f s t a b . (Lens.Labels.HasLens f s t "goPackage" a b) => + Lens.Family2.LensLike f s t a b +goPackage + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "goPackage") +identifierValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "identifierValue" a b) => + Lens.Family2.LensLike f s t a b +identifierValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "identifierValue") +inputType :: + forall f s t a b . (Lens.Labels.HasLens f s t "inputType" a b) => + Lens.Family2.LensLike f s t a b +inputType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "inputType") +isExtension :: + forall f s t a b . (Lens.Labels.HasLens f s t "isExtension" a b) => + Lens.Family2.LensLike f s t a b +isExtension + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "isExtension") +javaGenerateEqualsAndHash :: + forall f s t a b . + (Lens.Labels.HasLens f s t "javaGenerateEqualsAndHash" a b) => + Lens.Family2.LensLike f s t a b +javaGenerateEqualsAndHash + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "javaGenerateEqualsAndHash") +javaGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "javaGenericServices" a b) => + Lens.Family2.LensLike f s t a b +javaGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "javaGenericServices") +javaMultipleFiles :: + forall f s t a b . + (Lens.Labels.HasLens f s t "javaMultipleFiles" a b) => + Lens.Family2.LensLike f s t a b +javaMultipleFiles + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaMultipleFiles") +javaOuterClassname :: + forall f s t a b . + (Lens.Labels.HasLens f s t "javaOuterClassname" a b) => + Lens.Family2.LensLike f s t a b +javaOuterClassname + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaOuterClassname") +javaPackage :: + forall f s t a b . (Lens.Labels.HasLens f s t "javaPackage" a b) => + Lens.Family2.LensLike f s t a b +javaPackage + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaPackage") +javaStringCheckUtf8 :: + forall f s t a b . + (Lens.Labels.HasLens f s t "javaStringCheckUtf8" a b) => + Lens.Family2.LensLike f s t a b +javaStringCheckUtf8 + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "javaStringCheckUtf8") +jsonName :: + forall f s t a b . (Lens.Labels.HasLens f s t "jsonName" a b) => + Lens.Family2.LensLike f s t a b +jsonName + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "jsonName") +jstype :: + forall f s t a b . (Lens.Labels.HasLens f s t "jstype" a b) => + Lens.Family2.LensLike f s t a b +jstype + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "jstype") +label :: + forall f s t a b . (Lens.Labels.HasLens f s t "label" a b) => + Lens.Family2.LensLike f s t a b +label + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "label") +lazy :: + forall f s t a b . (Lens.Labels.HasLens f s t "lazy" a b) => + Lens.Family2.LensLike f s t a b +lazy + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "lazy") +leadingComments :: + forall f s t a b . + (Lens.Labels.HasLens f s t "leadingComments" a b) => + Lens.Family2.LensLike f s t a b +leadingComments + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "leadingComments") +leadingDetachedComments :: + forall f s t a b . + (Lens.Labels.HasLens f s t "leadingDetachedComments" a b) => + Lens.Family2.LensLike f s t a b +leadingDetachedComments + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "leadingDetachedComments") +location :: + forall f s t a b . (Lens.Labels.HasLens f s t "location" a b) => + Lens.Family2.LensLike f s t a b +location + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "location") +mapEntry :: + forall f s t a b . (Lens.Labels.HasLens f s t "mapEntry" a b) => + Lens.Family2.LensLike f s t a b +mapEntry + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "mapEntry") +maybe'aggregateValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'aggregateValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'aggregateValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'aggregateValue") +maybe'allowAlias :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'allowAlias" a b) => + Lens.Family2.LensLike f s t a b +maybe'allowAlias + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'allowAlias") +maybe'begin :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'begin" a b) => + Lens.Family2.LensLike f s t a b +maybe'begin + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'begin") +maybe'ccEnableArenas :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'ccEnableArenas" a b) => + Lens.Family2.LensLike f s t a b +maybe'ccEnableArenas + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'ccEnableArenas") +maybe'ccGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'ccGenericServices" a b) => + Lens.Family2.LensLike f s t a b +maybe'ccGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'ccGenericServices") +maybe'clientStreaming :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'clientStreaming" a b) => + Lens.Family2.LensLike f s t a b +maybe'clientStreaming + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'clientStreaming") +maybe'csharpNamespace :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'csharpNamespace" a b) => + Lens.Family2.LensLike f s t a b +maybe'csharpNamespace + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'csharpNamespace") +maybe'ctype :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'ctype" a b) => + Lens.Family2.LensLike f s t a b +maybe'ctype + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'ctype") +maybe'defaultValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'defaultValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'defaultValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'defaultValue") +maybe'deprecated :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'deprecated" a b) => + Lens.Family2.LensLike f s t a b +maybe'deprecated + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated") +maybe'doubleValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'doubleValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'doubleValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'doubleValue") +maybe'end :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'end" a b) => + Lens.Family2.LensLike f s t a b +maybe'end + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end") +maybe'extendee :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'extendee" a b) => + Lens.Family2.LensLike f s t a b +maybe'extendee + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'extendee") +maybe'goPackage :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'goPackage" a b) => + Lens.Family2.LensLike f s t a b +maybe'goPackage + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'goPackage") +maybe'identifierValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'identifierValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'identifierValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'identifierValue") +maybe'inputType :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'inputType" a b) => + Lens.Family2.LensLike f s t a b +maybe'inputType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'inputType") +maybe'javaGenerateEqualsAndHash :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaGenerateEqualsAndHash" a + b) => + Lens.Family2.LensLike f s t a b +maybe'javaGenerateEqualsAndHash + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaGenerateEqualsAndHash") +maybe'javaGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaGenericServices" a b) => + Lens.Family2.LensLike f s t a b +maybe'javaGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaGenericServices") +maybe'javaMultipleFiles :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaMultipleFiles" a b) => + Lens.Family2.LensLike f s t a b +maybe'javaMultipleFiles + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaMultipleFiles") +maybe'javaOuterClassname :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaOuterClassname" a b) => + Lens.Family2.LensLike f s t a b +maybe'javaOuterClassname + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaOuterClassname") +maybe'javaPackage :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaPackage" a b) => + Lens.Family2.LensLike f s t a b +maybe'javaPackage + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'javaPackage") +maybe'javaStringCheckUtf8 :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'javaStringCheckUtf8" a b) => + Lens.Family2.LensLike f s t a b +maybe'javaStringCheckUtf8 + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'javaStringCheckUtf8") +maybe'jsonName :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'jsonName" a b) => + Lens.Family2.LensLike f s t a b +maybe'jsonName + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jsonName") +maybe'jstype :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'jstype" a b) => + Lens.Family2.LensLike f s t a b +maybe'jstype + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jstype") +maybe'label :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'label" a b) => + Lens.Family2.LensLike f s t a b +maybe'label + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'label") +maybe'lazy :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'lazy" a b) => + Lens.Family2.LensLike f s t a b +maybe'lazy + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'lazy") +maybe'leadingComments :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'leadingComments" a b) => + Lens.Family2.LensLike f s t a b +maybe'leadingComments + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'leadingComments") +maybe'mapEntry :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'mapEntry" a b) => + Lens.Family2.LensLike f s t a b +maybe'mapEntry + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'mapEntry") +maybe'messageSetWireFormat :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'messageSetWireFormat" a b) => + Lens.Family2.LensLike f s t a b +maybe'messageSetWireFormat + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'messageSetWireFormat") +maybe'name :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'name" a b) => + Lens.Family2.LensLike f s t a b +maybe'name + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name") +maybe'negativeIntValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'negativeIntValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'negativeIntValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'negativeIntValue") +maybe'noStandardDescriptorAccessor :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'noStandardDescriptorAccessor" + a b) => + Lens.Family2.LensLike f s t a b +maybe'noStandardDescriptorAccessor + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'noStandardDescriptorAccessor") +maybe'number :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'number" a b) => + Lens.Family2.LensLike f s t a b +maybe'number + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number") +maybe'objcClassPrefix :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'objcClassPrefix" a b) => + Lens.Family2.LensLike f s t a b +maybe'objcClassPrefix + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'objcClassPrefix") +maybe'oneofIndex :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'oneofIndex" a b) => + Lens.Family2.LensLike f s t a b +maybe'oneofIndex + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'oneofIndex") +maybe'optimizeFor :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'optimizeFor" a b) => + Lens.Family2.LensLike f s t a b +maybe'optimizeFor + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'optimizeFor") +maybe'options :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'options" a b) => + Lens.Family2.LensLike f s t a b +maybe'options + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options") +maybe'outputType :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'outputType" a b) => + Lens.Family2.LensLike f s t a b +maybe'outputType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'outputType") +maybe'package :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'package" a b) => + Lens.Family2.LensLike f s t a b +maybe'package + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'package") +maybe'packed :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'packed" a b) => + Lens.Family2.LensLike f s t a b +maybe'packed + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'packed") +maybe'positiveIntValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'positiveIntValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'positiveIntValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'positiveIntValue") +maybe'pyGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'pyGenericServices" a b) => + Lens.Family2.LensLike f s t a b +maybe'pyGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'pyGenericServices") +maybe'serverStreaming :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'serverStreaming" a b) => + Lens.Family2.LensLike f s t a b +maybe'serverStreaming + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'serverStreaming") +maybe'sourceCodeInfo :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'sourceCodeInfo" a b) => + Lens.Family2.LensLike f s t a b +maybe'sourceCodeInfo + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'sourceCodeInfo") +maybe'sourceFile :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'sourceFile" a b) => + Lens.Family2.LensLike f s t a b +maybe'sourceFile + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'sourceFile") +maybe'start :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'start" a b) => + Lens.Family2.LensLike f s t a b +maybe'start + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start") +maybe'stringValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'stringValue" a b) => + Lens.Family2.LensLike f s t a b +maybe'stringValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'stringValue") +maybe'syntax :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'syntax" a b) => + Lens.Family2.LensLike f s t a b +maybe'syntax + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'syntax") +maybe'trailingComments :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'trailingComments" a b) => + Lens.Family2.LensLike f s t a b +maybe'trailingComments + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "maybe'trailingComments") +maybe'type' :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'type'" a b) => + Lens.Family2.LensLike f s t a b +maybe'type' + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'type'") +maybe'typeName :: + forall f s t a b . + (Lens.Labels.HasLens f s t "maybe'typeName" a b) => + Lens.Family2.LensLike f s t a b +maybe'typeName + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'typeName") +maybe'weak :: + forall f s t a b . (Lens.Labels.HasLens f s t "maybe'weak" a b) => + Lens.Family2.LensLike f s t a b +maybe'weak + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'weak") +messageSetWireFormat :: + forall f s t a b . + (Lens.Labels.HasLens f s t "messageSetWireFormat" a b) => + Lens.Family2.LensLike f s t a b +messageSetWireFormat + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "messageSetWireFormat") +messageType :: + forall f s t a b . (Lens.Labels.HasLens f s t "messageType" a b) => + Lens.Family2.LensLike f s t a b +messageType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "messageType") +method :: + forall f s t a b . (Lens.Labels.HasLens f s t "method" a b) => + Lens.Family2.LensLike f s t a b +method + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "method") +name :: + forall f s t a b . (Lens.Labels.HasLens f s t "name" a b) => + Lens.Family2.LensLike f s t a b +name + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name") +namePart :: + forall f s t a b . (Lens.Labels.HasLens f s t "namePart" a b) => + Lens.Family2.LensLike f s t a b +namePart + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "namePart") +negativeIntValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "negativeIntValue" a b) => + Lens.Family2.LensLike f s t a b +negativeIntValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "negativeIntValue") +nestedType :: + forall f s t a b . (Lens.Labels.HasLens f s t "nestedType" a b) => + Lens.Family2.LensLike f s t a b +nestedType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nestedType") +noStandardDescriptorAccessor :: + forall f s t a b . + (Lens.Labels.HasLens f s t "noStandardDescriptorAccessor" a b) => + Lens.Family2.LensLike f s t a b +noStandardDescriptorAccessor + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "noStandardDescriptorAccessor") +number :: + forall f s t a b . (Lens.Labels.HasLens f s t "number" a b) => + Lens.Family2.LensLike f s t a b +number + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "number") +objcClassPrefix :: + forall f s t a b . + (Lens.Labels.HasLens f s t "objcClassPrefix" a b) => + Lens.Family2.LensLike f s t a b +objcClassPrefix + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "objcClassPrefix") +oneofDecl :: + forall f s t a b . (Lens.Labels.HasLens f s t "oneofDecl" a b) => + Lens.Family2.LensLike f s t a b +oneofDecl + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofDecl") +oneofIndex :: + forall f s t a b . (Lens.Labels.HasLens f s t "oneofIndex" a b) => + Lens.Family2.LensLike f s t a b +oneofIndex + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofIndex") +optimizeFor :: + forall f s t a b . (Lens.Labels.HasLens f s t "optimizeFor" a b) => + Lens.Family2.LensLike f s t a b +optimizeFor + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "optimizeFor") +options :: + forall f s t a b . (Lens.Labels.HasLens f s t "options" a b) => + Lens.Family2.LensLike f s t a b +options + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "options") +outputType :: + forall f s t a b . (Lens.Labels.HasLens f s t "outputType" a b) => + Lens.Family2.LensLike f s t a b +outputType + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "outputType") +package :: + forall f s t a b . (Lens.Labels.HasLens f s t "package" a b) => + Lens.Family2.LensLike f s t a b +package + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "package") +packed :: + forall f s t a b . (Lens.Labels.HasLens f s t "packed" a b) => + Lens.Family2.LensLike f s t a b +packed + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "packed") +path :: + forall f s t a b . (Lens.Labels.HasLens f s t "path" a b) => + Lens.Family2.LensLike f s t a b +path + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path") +positiveIntValue :: + forall f s t a b . + (Lens.Labels.HasLens f s t "positiveIntValue" a b) => + Lens.Family2.LensLike f s t a b +positiveIntValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "positiveIntValue") +publicDependency :: + forall f s t a b . + (Lens.Labels.HasLens f s t "publicDependency" a b) => + Lens.Family2.LensLike f s t a b +publicDependency + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "publicDependency") +pyGenericServices :: + forall f s t a b . + (Lens.Labels.HasLens f s t "pyGenericServices" a b) => + Lens.Family2.LensLike f s t a b +pyGenericServices + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "pyGenericServices") +reservedName :: + forall f s t a b . + (Lens.Labels.HasLens f s t "reservedName" a b) => + Lens.Family2.LensLike f s t a b +reservedName + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedName") +reservedRange :: + forall f s t a b . + (Lens.Labels.HasLens f s t "reservedRange" a b) => + Lens.Family2.LensLike f s t a b +reservedRange + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedRange") +serverStreaming :: + forall f s t a b . + (Lens.Labels.HasLens f s t "serverStreaming" a b) => + Lens.Family2.LensLike f s t a b +serverStreaming + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "serverStreaming") +service :: + forall f s t a b . (Lens.Labels.HasLens f s t "service" a b) => + Lens.Family2.LensLike f s t a b +service + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "service") +sourceCodeInfo :: + forall f s t a b . + (Lens.Labels.HasLens f s t "sourceCodeInfo" a b) => + Lens.Family2.LensLike f s t a b +sourceCodeInfo + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sourceCodeInfo") +sourceFile :: + forall f s t a b . (Lens.Labels.HasLens f s t "sourceFile" a b) => + Lens.Family2.LensLike f s t a b +sourceFile + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sourceFile") +span :: + forall f s t a b . (Lens.Labels.HasLens f s t "span" a b) => + Lens.Family2.LensLike f s t a b +span + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "span") +start :: + forall f s t a b . (Lens.Labels.HasLens f s t "start" a b) => + Lens.Family2.LensLike f s t a b +start + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "start") +stringValue :: + forall f s t a b . (Lens.Labels.HasLens f s t "stringValue" a b) => + Lens.Family2.LensLike f s t a b +stringValue + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "stringValue") +syntax :: + forall f s t a b . (Lens.Labels.HasLens f s t "syntax" a b) => + Lens.Family2.LensLike f s t a b +syntax + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "syntax") +trailingComments :: + forall f s t a b . + (Lens.Labels.HasLens f s t "trailingComments" a b) => + Lens.Family2.LensLike f s t a b +trailingComments + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "trailingComments") +type' :: + forall f s t a b . (Lens.Labels.HasLens f s t "type'" a b) => + Lens.Family2.LensLike f s t a b +type' + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "type'") +typeName :: + forall f s t a b . (Lens.Labels.HasLens f s t "typeName" a b) => + Lens.Family2.LensLike f s t a b +typeName + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "typeName") +uninterpretedOption :: + forall f s t a b . + (Lens.Labels.HasLens f s t "uninterpretedOption" a b) => + Lens.Family2.LensLike f s t a b +uninterpretedOption + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: + (Lens.Labels.Proxy#) "uninterpretedOption") +value :: + forall f s t a b . (Lens.Labels.HasLens f s t "value" a b) => + Lens.Family2.LensLike f s t a b +value + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value") +weak :: + forall f s t a b . (Lens.Labels.HasLens f s t "weak" a b) => + Lens.Family2.LensLike f s t a b +weak + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weak") +weakDependency :: + forall f s t a b . + (Lens.Labels.HasLens f s t "weakDependency" a b) => + Lens.Family2.LensLike f s t a b +weakDependency + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weakDependency")