diff --git a/Changelog.md b/Changelog.md new file mode 100644 --- /dev/null +++ b/Changelog.md @@ -0,0 +1,127 @@ +# Changelog for `proto-lens-protoc` + +## v0.9.0.1 +- Support GHC 9.12. +- Support GHC 9.14. + +## v0.9.0.0 +- Support Protobuf Editions 2023 and 2024. +- Update bootstrap protobuf bindings to protobuf v28.0. +- Relax upper bounds for ghc-9.10. + +## v0.8.0.0 +- Relax upper bounds for ghc-9.6 +- Incompatible change: change `forall` to `forall'` in generated code + due to GHC warning of the upcoming change. + +## v0.7.1.1 +- Relax upper bounds for ghc-9.2 + +## v0.7.1.0 +- Support GHC 9.0. +- Add ServiceDescriptor to generated services. (#409) +- Support proto3 optional (#400) + +## v0.7.0.0 +- Support GHC 8.10. +- Support `proto-lens` changes for the new method `packedMessageDescriptor`. +- Bump upper bound to allow base-4.14. +- Bump to ghc-source-gen-0.4.0.0. + +### Breaking Changes +- Reexport transitive definitions from modules generated for `.proto` files + with `import public` statements (#329). +- Bump lower bounds to base-4.10 (ghc-8.2). +- Use `ghc-source-gen` instead of `haskell-src-exts`. Removes + `Data.ProtoLens.Compiler.Combinators` and adds + `Data.ProtoLens.Compiler.Definitions`. +- Limit the exposed library to a single module + `Data.ProtoLens.Compiler.ModuleName`. The other modules were not + used in practice, and exposed internals unnecessarily. + +### Backwards-Compatible Changes +- Fix a potential naming conflict when message types and enum values + are the same except for case. +- Support dependencies on base-4.13 (ghc-8.8) and lens-family-2.0. + +## v0.5.0.0 + +### Breaking Changes +- Capitalize enum values, and capitalize names of enum sub-messages (#270). +- Fix the parser to fail on end-group markers with the wrong tag number (#282). + +### Backwards-Compatible Changes +- Allow enum names that start with underscores. (#238) +- Track changes to `proto-lens`: use generated Haskell code and a custom + parsing monad to encode/decode proto messages faster. +- Store repeated fields internally as `Vector`s, and expose the internal + representation via new `vec'*` lenses. (#302) +- Use `Vector`s for more efficient encoding/decoding. +- Add more combinators to support the generated code. + +## v0.4.0.1 +- Bump the dependency on `base` and `containers` to support `ghc-8.6.1`. +- Fix a GHC error on enums with a very large number of cases (#241). + +## v0.4.0.0 +- Split out `proto-lens-setup` and `proto-lens-runtime` into separate + packages. +- Hide the constructors and record fields of message types, and make `Show` + instances call `showMessageShort`. +- Generate explicit `NFData` instances for each type. +- Track the change to `proto-lens`: Don't use `data-default` for + default proto values (#194). +- Use simplified lens-labels instances. (#208) + +## v0.3.1.2 +- Bump the upper bound to `temporary-1.3`. +- Fix warnings. + +## v0.3.1.1 +- Fix management of generated files between Cabal components (#171). +- Bump the lower bound on `base` to indicate we require `ghc>=8.0`. +- Use autogen-modules. (#196) + +## v0.3.1.0 +- Bump the dependency on `base` for `ghc-8.4.2`. +- Bump the dependency to `Cabal-2.2.*`. +- Make `Symbol` an instance of Semigroup. + +## v0.3.0.0 +- Remove support for `ghc-7.10`. (#136) +- Use a `.cabal` file that's auto-generated from `hpack`. (#138) +- Separate types into their own module, apart from field lenses. +- Improve readability of `HasLens` instances. (#118) +- Add support for tracking unknown fields. (#129) +- Don't generate Haskell modules if they won't be used. (#126) +- Bundle enum pattern synonyms exports with their type. (#136) +- Split the `Message` class into separate methods. (#139) +- Refactor the `FieldDescriptorType`. (#147) +- Add a case to proto3 enums for unknown values. (#137) +- Track consolidation of `proto-lens-descriptors` into `proto-lens`. (#140) +- Generate service definitions using promoted datatypes. (#154) +- Generate prisms for `oneof` message fields. (#160) + +## v0.2.2.3 +- Don't camel-case message names. This reverts behavior which was added + in v0.2.2.0. + +## v0.2.2.2 +- Bump the dependency for `process-1.6`. + +## v0.2.2.1 +- Fix the case where types/constructors of oneofs overlap with those of + submessages or subenums, by appending `"'"` to the former when required. + +## v0.2.2.0 +- Bump the dependency on `base` to support `ghc-8.2.1` and `Cabal-2.0`. +- Bump the dependency for `haskell-src-exts-0.19`. +- Improve the semantics of oneof fields, and add a lens to access the + underlying sum type. +- Generate Ord instances for all exported datatypes. +- Print a better error message when missing `protoc` or `proto-lens-protoc`. +- Expose message names to support `Data.ProtoLens.Any`. +- CamelCase the names of Haskell message types. + +## v0.2.1.0 and older +See `Changelog.md` for `proto-lens`. diff --git a/app/Data/ProtoLens/Compiler/Definitions.hs b/app/Data/ProtoLens/Compiler/Definitions.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Definitions.hs @@ -0,0 +1,712 @@ +-- Copyright 2016 Google Inc. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd + +-- | This module takes care of collecting all the definitions in a .proto file +-- and assigning Haskell names to all of the defined things (messages, enums +-- and field names). +{-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} +module Data.ProtoLens.Compiler.Definitions + ( Env + , Definition(..) + , MessageInfo(..) + , ServiceInfo(..) + , MethodInfo(..) + , PlainFieldInfo(..) + , FieldInfo(..) + , FieldKind(..) + , FieldPacking(..) + , MapEntryInfo(..) + , OneofInfo(..) + , OneofCase(..) + , FieldName(..) + , Symbol + , nameFromSymbol + , promoteSymbol + , EnumInfo(..) + , EnumValueInfo(..) + , EnumUnrecognizedInfo(..) + , qualifyEnv + , unqualifyEnv + , collectDefinitions + , collectServices + , definedFieldType + , definedType + , camelCase + , overloadedFieldName + ) where + +import Data.Char (isUpper, toUpper) +import Data.Int (Int32) +import Data.List (mapAccumL) +import qualified Data.Map as Map +import Data.Maybe (catMaybes, fromMaybe) +#if !MIN_VERSION_base(4,11,0) +import Data.Monoid ((<>)) +#endif +import Data.ProtoLens.Labels () +import Data.ProtoLens.Compiler.Editions.Features + ( featuresForEdition + , mergedInto + ) +import qualified Data.Semigroup as Semigroup +import qualified Data.Set as Set +import Data.String (IsString(..)) +import Data.Text (Text, cons, splitOn, toLower, uncons, unpack) +import qualified Data.Text as T +import Data.Tree + ( Tree(..) + , Forest + , flatten + ) +import Lens.Family2 ((^.), (^..), toListOf) +import Proto.Google.Protobuf.Descriptor + ( DescriptorProto + , Edition(..) + , EnumDescriptorProto + , EnumValueDescriptorProto + , FeatureSet + , FeatureSet'EnumType(..) + , FeatureSet'FieldPresence(..) + , FeatureSet'MessageEncoding(..) + , FeatureSet'RepeatedFieldEncoding(..) + , FieldDescriptorProto + , FieldDescriptorProto'Label(..) + , FieldDescriptorProto'Type(..) + , FileDescriptorProto + , MethodDescriptorProto + , ServiceDescriptorProto + ) +import GHC.SourceGen + ( OccNameStr + , RdrNameStr + , ModuleNameStr + , HsType' + , qual + , stringTy + , unqual + ) + +-- | 'Env' contains a mapping of proto names (as specified in the .proto file) +-- to Haskell names. The keys are fully-qualified names, for example, +-- ".package.Message.Submessage". (The protocol_compiler tool emits all +-- message field types in this form, even if they refer to local definitions.) +-- +-- The type 'n' can be either a 'Name' (when talking about definitions within +-- the current file) or a (qualified) 'RdrNameStr' (when talking about definitions +-- either from this or another file). +type Env n = Map.Map Text (Definition n) + +{-| Returns the edition for the file. + +For proto2 and proto3 files, 'EDITION_PROTO2' and 'EDITION_PROTO3' are returned, +respectively, which will map to the equivalent feature set compatible with +proto2 and proto3. + +>>> fileEdition $ defMessage & #syntax .~ "proto2" +Right EDITION_PROTO2 +>>> fileEdition $ defMessage & #syntax .~ "proto3" +Right EDITION_PROTO3 + +-} +fileEdition :: FileDescriptorProto -> Either Text Edition +fileEdition f = case f ^. #syntax of + "editions" -> Right $ f ^. #edition + "proto3" -> Right EDITION_PROTO3 + "proto2" -> Right EDITION_PROTO2 + "" -> Right EDITION_PROTO2 + s -> Left $ "Unknown syntax type " <> T.pack (show s) + +{-| Returns the feature defaults for the file. + +This includes the file-scope options which override +the feature defaults for an edition. +-} +fileFeatures :: FileDescriptorProto -> Either Text FeatureSet +fileFeatures f = do + edition <- fileEdition f + features <- featuresForEdition edition + return $ case f ^. #options . #maybe'features of + Just overrides -> overrides `mergedInto` features + Nothing -> features + +data Definition n = Message (MessageInfo n) | Enum (EnumInfo n) + deriving Functor + +-- | All the information needed to define or use a proto message type. +data MessageInfo n = MessageInfo + { messageName :: n -- ^ Haskell type name + , messageConstructorName :: n -- ^ Haskell constructor name + , messageDescriptor :: DescriptorProto + , messageFields :: [PlainFieldInfo] + -- ^ Fields not belonging to a oneof. This includes proto3 + -- optional fields even though they are part of a synthetic + -- oneof. + , messageOneofFields :: [OneofInfo] + -- ^ The oneofs in this message, associated with the fields that + -- belong to them. Does not include synthetic oneofs generated + -- for proto3 optional fields. + , messageUnknownFields :: OccNameStr + -- ^ The name of the Haskell field in this message that holds the + -- unknown fields. + , groupFieldNumber :: Maybe Int32 + -- ^ The number of the field that holds this message, if it is a group. + } deriving Functor + +data ServiceInfo = ServiceInfo + { serviceName :: Text + , servicePackage :: Text + , serviceMethods :: [MethodInfo] + , serviceDescriptor :: ServiceDescriptorProto + } + +data MethodInfo = MethodInfo + { methodName :: Text + , methodIdent :: Text + , methodInput :: Text + , methodOutput :: Text + , methodClientStreaming :: Bool + , methodServerStreaming :: Bool + } + +-- | Information about a single field of a proto message, +-- associated with how it is stored. +data PlainFieldInfo = PlainFieldInfo + { plainFieldKind :: FieldKind + , plainFieldInfo :: FieldInfo + } + +-- | Information about a single field of a proto message. +data FieldInfo = FieldInfo + { fieldDescriptor :: FieldDescriptorProto + , fieldName :: FieldName + } + +-- | How a field is stored inside of the proto message. +data FieldKind + = RequiredField + -- ^ A proto2 required field. Stored internally as a value. + | OptionalValueField + -- ^ A proto3 scalar field. Stored internally as a value, and + -- defaults to corresponding instance of fieldDefault. + | OptionalMaybeField + -- ^ An optional field where the "unset" and "default" values + -- are distinguishable. Stored internally as a Maybe. + -- In particular: proto2 optional fields, proto3 messages, + -- proto3 explicitly optional fields and "oneof" fields. + | RepeatedField FieldPacking + -- ^ A field containing a sequence of values. + -- Stored internally as either a list or a map, depending on + -- whether the field's FieldDescriptorProto of the field has + -- options.map_entry set. + | MapField MapEntryInfo + -- ^ A field containing a map of keys to values. + -- Serialized as a repeated field of an autogenerated "entry" + -- proto type, each instance of which contains a key-value pair. + +data FieldPacking + = NotPackable -- ^ Cannot be packed (e.g., strings or messages). + | Packable -- ^ Can be decoded as packed, but should not be not be + -- encoded as packed by default. + | Packed -- ^ Can be decoded as packed, and should be encoded + -- as packed by default. + deriving Eq + +data OneofInfo = OneofInfo + { oneofFieldName :: FieldName + , oneofTypeName :: OccNameStr + -- ^ The name of the sum type corresponding to this oneof. + , oneofCases :: [OneofCase] + -- ^ The individual fields that make up this oneof. + } + +data OneofCase = OneofCase + { caseField :: FieldInfo + , caseConstructorName :: OccNameStr + -- ^ The constructor for building a 'oneofTypeName' from the + -- value in this field. + , casePrismName :: OccNameStr + -- ^ The name for building 'Prism' definition. + } + +-- | The "entry" type for a map field is a proto message, autogenerated by +-- protoc, that has two fields: a key and a value. The map field should be +-- serialized like a repeated field of the entry messages. +data MapEntryInfo = MapEntryInfo + { mapEntryTypeName :: OccNameStr + -- ^ The Haskell name for this type. + , keyField :: FieldInfo + -- ^ The field of the entry type corresponding to the map key. + , valueField :: FieldInfo + -- ^ The field of the entry type corresponding to the map value. + } + +data FieldName = FieldName + { overloadedName :: Symbol + -- ^ The overloaded name of lenses that access this field. + -- For example, if the field is called "foo_bar" in the .proto + -- then @overloadedName == "fooBar"@ and we might generate + -- @fooBar@ and/or @maybe'fooBar@ lenses to access the data. + -- + -- May be shared between two different message data types in the same + -- module. + , haskellRecordFieldName :: OccNameStr + -- ^ The Haskell name of this internal record field; for example, + -- "_Foo'Bar'baz. Unique within each module. + } + +-- | A string that refers to the name (in Haskell) of a lens that accesses a +-- field. +-- +-- For example, in the signature of the overloaded lens +-- +-- @ +-- foo :: HasLens "foo" ... => Lens ... +-- @ +-- +-- a 'Symbol' is used to construct both the type-level argument to +-- @HasLens@ and the name of the function @foo@. +newtype Symbol = Symbol String + deriving (Eq, Ord, IsString, Semigroup.Semigroup, Monoid) + +nameFromSymbol :: Symbol -> OccNameStr +nameFromSymbol (Symbol s) = fromString s + +-- | Construct a promoted, type-level string. +promoteSymbol :: Symbol -> HsType' +promoteSymbol (Symbol s) = stringTy s + +-- | All the information needed to define or use a proto enum type. +data EnumInfo n = EnumInfo + { enumName :: n + , enumUnrecognized :: Maybe EnumUnrecognizedInfo + , enumDescriptor :: EnumDescriptorProto + , enumValues :: [EnumValueInfo n] + } deriving Functor + +-- | Information about the "unrecognized" case of an enum. +data EnumUnrecognizedInfo = EnumUnrecognizedInfo + { unrecognizedName :: OccNameStr + , unrecognizedValueName :: OccNameStr + } + +-- | Information about a single value case of a proto enum. +data EnumValueInfo n = EnumValueInfo + { enumValueName :: n + , enumValueDescriptor :: EnumValueDescriptorProto + , enumAliasOf :: Maybe OccNameStr + -- ^ If 'Nothing', we turn value into a normal constructor of the enum. + -- If @'Just' n@, we're treating it as an alias of the constructor @n@ + -- (a PatternSynonym in Haskell). This mirrors the behavior of the + -- Java API. + } deriving Functor + +mapEnv :: (n -> n') -> Env n -> Env n' +mapEnv f = fmap $ fmap f + +-- Lift a set of local definitions into references to a specific module. +qualifyEnv :: ModuleNameStr -> Env OccNameStr -> Env RdrNameStr +qualifyEnv m = mapEnv (qual m) + +-- Lift a set of local definitions into references to the current module. +unqualifyEnv :: Env OccNameStr -> Env RdrNameStr +unqualifyEnv = mapEnv unqual + +-- | Look up the Haskell name for the type of a given field (message or enum). +definedFieldType :: FieldDescriptorProto -> Env RdrNameStr -> Definition RdrNameStr +definedFieldType fd env = fromMaybe err $ Map.lookup (fd ^. #typeName) env + where + err = error $ "definedFieldType: Field type " ++ unpack (fd ^. #typeName) + ++ " not found in environment." + +-- | Look up the Haskell name for the type of a given type. +definedType :: Text -> Env RdrNameStr -> Definition RdrNameStr +definedType ty = fromMaybe err . Map.lookup ty + where + err = error $ "definedType: Type " ++ unpack ty + ++ " not found in environment." + +-- | Collect all the definitions in the given file (including definitions +-- nested in other messages), and assign Haskell names to them. +collectDefinitions :: FileDescriptorProto -> Either Text (Env OccNameStr) +collectDefinitions fd = do + let protoPrefix = case fd ^. #package of + "" -> "." + p -> "." <> p <> "." + let hsPrefix = "" + features <- fileFeatures fd + return $ Map.fromList $ concatMap flatten $ + messageAndEnumDefs + features protoPrefix hsPrefix Map.empty + (fd ^. #messageType) (fd ^. #enumType) + +collectServices :: FileDescriptorProto -> [ServiceInfo] +collectServices fd = fmap (toServiceInfo $ fd ^. #package) $ fd ^. #service + where + toServiceInfo :: Text -> ServiceDescriptorProto -> ServiceInfo + toServiceInfo pkg sd = + ServiceInfo + { serviceName = sd ^. #name + , servicePackage = pkg + , serviceMethods = fmap toMethodInfo $ sd ^. #method + , serviceDescriptor = sd + } + + toMethodInfo :: MethodDescriptorProto -> MethodInfo + toMethodInfo md = + MethodInfo + { methodName = md ^. #name + , methodIdent = camelCase $ md ^. #name + , methodInput = fromString . T.unpack $ md ^. #inputType + , methodOutput = fromString . T.unpack $ md ^. #outputType + , methodClientStreaming = md ^. #clientStreaming + , methodServerStreaming = md ^. #serverStreaming + } + +messageAndEnumDefs :: + FeatureSet -> Text -> String + -> GroupMap + -- ^ Group fields of the parent message (if any). + -> [DescriptorProto] + -> [EnumDescriptorProto] + -> Forest (Text, Definition OccNameStr) + -- ^ Organized as a list of trees, to make it possible for callers + -- to get the immediate child nested types. +messageAndEnumDefs features protoPrefix hsPrefix groups messages enums + = map (messageDefs features protoPrefix hsPrefix groups) messages + ++ map + (flip Node [] -- Enums have no sub-definitions + . enumDef features protoPrefix hsPrefix) + enums + +-- | Generate the definitions for a message and its nested types (if any). +messageDefs :: FeatureSet -> Text -> String -> GroupMap -> DescriptorProto + -> Tree (Text, Definition OccNameStr) +messageDefs features protoPrefix hsPrefix groups d + = Node (protoName, thisDef) subDefs + where + protoName = protoPrefix <> d ^. #name + hsPrefix' = hsPrefix ++ hsName (d ^. #name) ++ "'" + allFields = groupFieldsByOneofIndex (d ^. #field) + thisDef = + Message MessageInfo + { messageName = fromString $ hsPrefix ++ hsName (d ^. #name) + -- Set the constructor name to not conflict with enum values. + , messageConstructorName = + fromString $ hsPrefix ++ hsName (d ^. #name) + ++ "'_constructor" + , messageDescriptor = d + , messageFields = + map (PlainFieldInfo <$> + fieldKind features' mapEntries <*> fieldInfo hsPrefix') + $ Map.findWithDefault [] Nothing allFields + , messageOneofFields = collectOneofFields hsPrefix' d allFields + , messageUnknownFields = + fromString $ "_" ++ hsPrefix' ++ "_unknownFields" + , groupFieldNumber = Map.lookup protoName groups + } + subDefs = messageAndEnumDefs + features' + (protoName <> ".") + hsPrefix' + (collectGroupFields $ d ^. #field) + (d ^. #nestedType) + (d ^. #enumType) + -- For efficiency, only look for map entries within the immediate + -- nested types, rather than recursively searching through all of them. + mapEntries = collectMapEntries $ map rootLabel subDefs + -- Include message-scope feature overrides. + features' = case d ^. #options . #maybe'features of + Just overrides -> overrides `mergedInto ` features + Nothing -> features + +-- | If this type is a map entry, retrieves the relevant information +-- along with the proto name of this type. +mapEntryInfo :: Definition OccNameStr -> Maybe MapEntryInfo +mapEntryInfo (Message m) + | messageDescriptor m ^. #options . #mapEntry + , [keyFd, valueFd] <- messageFields m + = Just MapEntryInfo + { mapEntryTypeName = messageName m + , keyField = plainFieldInfo keyFd + , valueField = plainFieldInfo valueFd + } +mapEntryInfo _ = Nothing + +-- | Returns a map whose keys are the proto type name of the entry message. +collectMapEntries :: [(Text, Definition OccNameStr)] -> Map.Map Text MapEntryInfo +collectMapEntries defs = + Map.fromList + [(protoName, e) | (protoName, d) <- defs, Just e <- [mapEntryInfo d]] + +-- | A map whose keys are the proto type names of the groups in a message, +-- and values are the field numbers for those groups. +-- (Every group corresponds to exactly one message field.) +type GroupMap = Map.Map Text Int32 + +collectGroupFields :: [FieldDescriptorProto] -> GroupMap +collectGroupFields fs = Map.fromList + [ (f ^. #typeName, f ^. #number) + | f <- fs + , (f ^. #type' == FieldDescriptorProto'TYPE_GROUP) || + -- Message fields with DELIMITED encoding are the same as proto2 groups. + (f ^. #options . #features . #messageEncoding == FeatureSet'DELIMITED) + ] + +fieldInfo :: String -> FieldDescriptorProto -> FieldInfo +fieldInfo hsPrefix f = FieldInfo + { fieldDescriptor = f + , fieldName = mkFieldName hsPrefix $ f ^. #name + } + +fieldKind :: + FeatureSet -> Map.Map Text MapEntryInfo -> FieldDescriptorProto + -> FieldKind +fieldKind features mapEntries f = case f ^. #label of + FieldDescriptorProto'LABEL_OPTIONAL -> + case features' ^. #fieldPresence of + FeatureSet'IMPLICIT + | f ^. #type' /= FieldDescriptorProto'TYPE_MESSAGE + && not (f ^. #proto3Optional) + -> OptionalValueField + | otherwise -> OptionalMaybeField + FeatureSet'EXPLICIT -> OptionalMaybeField + FeatureSet'LEGACY_REQUIRED -> RequiredField + _ -> error $ "Has unknown field presence: " ++ show (f ^. #name) + FieldDescriptorProto'LABEL_REQUIRED -> RequiredField + FieldDescriptorProto'LABEL_REPEATED + | Just entryInfo <- Map.lookup (f ^. #typeName) mapEntries + -> MapField entryInfo + | otherwise -> RepeatedField packed + where + packed + | f ^. #type' `elem` unpackableTypes = NotPackable + | packedByDefault = Packed + | otherwise = Packable + + packedByDefault = + fromMaybe (features' ^. #repeatedFieldEncoding == FeatureSet'PACKED) + $ f ^. #options . #maybe'packed + + unpackableTypes = + [ FieldDescriptorProto'TYPE_MESSAGE + , FieldDescriptorProto'TYPE_GROUP + , FieldDescriptorProto'TYPE_STRING + , FieldDescriptorProto'TYPE_BYTES + ] + + -- Include field-scope feature overrides + features' = case f ^. #options . #maybe'features of + Just overrides -> overrides `mergedInto` features + Nothing -> features + +collectOneofFields + :: String -> DescriptorProto -> Map.Map (Maybe Int32) [FieldDescriptorProto] + -> [OneofInfo] +collectOneofFields hsPrefix d allFields + = catMaybes $ zipWith oneofMaybe [0..] $ d ^.. #oneofDecl . traverse . #name + where + oneofMaybe idx n = + let fields = Map.findWithDefault [] (Just idx) allFields + in if isSynthetic fields + then Nothing + else Just $ oneofInfo n fields + oneofInfo n fields = OneofInfo + { oneofFieldName = mkFieldName hsPrefix n + , oneofTypeName = fromString $ hsPrefix ++ hsNameUnique subdefTypes n + , oneofCases = map oneofCase fields + } + -- The oneof is synthetic if it contains a single proto3_optional field. + isSynthetic :: [FieldDescriptorProto] -> Bool + isSynthetic [f] = f ^. #proto3Optional + isSynthetic _ = False + oneofCase f = + let consName = hsPrefix ++ hsNameUnique subdefCons (f ^. #name) + in OneofCase + { caseField = fieldInfo hsPrefix f + , caseConstructorName = + -- Note: oneof case constructors aren't prefixed + -- by the oneof name; field names (even inside + -- of a oneof) are unique within a message. + fromString consName + , casePrismName = + fromString $ "_" ++ consName + } + -- Make a name that doesn't overlap with those already defined by submessages + -- or subenums. + hsNameUnique ns n + | n' `elem` ns = n' ++ "'" + | otherwise = n' + where + n' = hsName $ camelCase n + -- The Haskell "type" namespace + subdefTypes = Set.fromList $ map hsName + $ toListOf (#nestedType . traverse . #name) d + ++ toListOf (#enumType . traverse . #name) d + -- The Haskell "expression" namespace (i.e., constructors) + subdefCons = Set.fromList $ map hsName + $ toListOf (#nestedType . traverse . #name) d + ++ toListOf (#enumType . traverse . #value . traverse . #name) d + +-- | Group fields by the index of the oneof field that they belong to. +-- Or 'Nothing' if they don't belong to a oneof. Proto3 optional +-- fields are included twice, both as members of their synthetic oneof +-- (so that collectOneofFields can use them to recognize synthetic +-- oneofs) and as stand-alone fields for which we generate bindings. +groupFieldsByOneofIndex + :: [FieldDescriptorProto] -> Map.Map (Maybe Int32) [FieldDescriptorProto] +groupFieldsByOneofIndex = + fmap reverse + . Map.fromListWith (++) + . concatMap mapElementsForField + where + mapElementsForField + :: FieldDescriptorProto -> [(Maybe Int32, [FieldDescriptorProto])] + mapElementsForField f = case f ^. #maybe'oneofIndex of + Nothing -> [(Nothing, [f])] + Just idx -> if f ^. #proto3Optional + then [(Nothing, [f]), (Just idx, [f])] + else [(Just idx, [f])] + +hsName :: Text -> String +hsName = unpack . capitalize + +mkFieldName :: String -> Text -> FieldName +mkFieldName hsPrefix n = FieldName + { overloadedName = fromString n' + , haskellRecordFieldName = fromString $ "_" ++ hsPrefix ++ n' + } + where + n' = fieldBaseName n + +-- | Get the name in Haskell of a proto field, taking care of camel casing and +-- clashes with language keywords. Doesn't handle the name prefix of the +-- containing type. +fieldBaseName :: Text -> String +fieldBaseName = unpack . disambiguate . camelCase + where + disambiguate s + | s `Set.member` reservedKeywords = s <> "'" + | otherwise = s + +camelCase :: Text -> Text +camelCase s = + -- Preserve any initial underlines (e.g., "_foo_bar" -> "_fooBar"). + let (underlines, rest) = T.span (== '_') s + in case splitOn "_" rest of + -- splitOn always returns a list with at least one element. + [] -> error $ "camelCase: splitOn returned empty list: " + ++ show rest + [""] -> error $ "camelCase: name consists only of underscores: " + ++ show s + s':ss -> T.concat $ underlines : lowerInitialChars s' : map capitalize ss + +-- | Lower-case all initial upper-case characters. +-- For example: "Foo" -> "foo", "FooBar" -> "fooBar", "FOObar" -> "foobar" +lowerInitialChars :: Text -> Text +lowerInitialChars s = toLower pre <> post + where (pre, post) = T.span isUpper s + +-- | A list of reserved keywords that aren't valid as variable names. +reservedKeywords :: Set.Set Text +reservedKeywords = Set.fromList $ + -- Haskell2010 keywords: + -- https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4 + -- We don't include keywords that are allowed to be variable names, + -- in particular: "as" and "hiding". + [ "case" + , "class" + , "data" + , "default" + , "deriving" + , "do" + , "else" + , "forall" + , "foreign" + , "if" + , "import" + , "in" + , "infix" + , "infixl" + , "infixr" + , "instance" + , "let" + , "module" + , "newtype" + , "of" + , "then" + , "type" + , "where" + ] + ++ -- Nonstandard extensions + [ "mdo" -- RecursiveDo + , "rec" -- Arrows, RecursiveDo + , "pattern" -- PatternSynonyms + , "proc" -- Arrows + ] + +-- | Generate the definition for an enum type. +enumDef :: FeatureSet -> Text -> String -> EnumDescriptorProto + -> (Text, Definition OccNameStr) +enumDef features protoPrefix hsPrefix d = let + mkText n = protoPrefix <> n + mkHsName n = fromString $ hsPrefix ++ case hsName n of + ('_':xs) -> 'X':xs + xs -> xs + -- Include enum-scope feature overrides. + features' = case d ^. #options . #maybe'features of + Just overrides -> overrides `mergedInto` features + Nothing -> features + in (mkText (d ^. #name) + , Enum EnumInfo + { enumName = mkHsName (d ^. #name) + , enumUnrecognized = case features' ^. #enumType of + FeatureSet'CLOSED -> Nothing + FeatureSet'OPEN -> + Just EnumUnrecognizedInfo + { unrecognizedName + = mkHsName (d ^. #name <> "'Unrecognized") + , unrecognizedValueName + = mkHsName (d ^. #name <> "'UnrecognizedValue") + } + _ -> error $ "Has unknown enum type: " ++ show (d ^. #name) + , enumDescriptor = d + , enumValues = collectEnumValues mkHsName $ d ^. #value + }) + +-- | Generate the definitions for each enum value. In particular, decide +-- whether it's a true constructor or a PatternSynonym to another +-- constructor. +-- +-- Like Java, we treat the first case of each numeric value as the "real" +-- constructor, and subsequent cases as synonyms. +collectEnumValues :: (Text -> OccNameStr) -> [EnumValueDescriptorProto] + -> [EnumValueInfo OccNameStr] +collectEnumValues mkHsName = snd . mapAccumL helper Map.empty + where + helper :: Map.Map Int32 OccNameStr -> EnumValueDescriptorProto + -> (Map.Map Int32 OccNameStr, EnumValueInfo OccNameStr) + helper seenNames v + | Just n' <- Map.lookup k seenNames = (seenNames, mkValue (Just n')) + | otherwise = (Map.insert k n seenNames, mkValue Nothing) + where + mkValue = EnumValueInfo n v + n = mkHsName (v ^. #name) + k = v ^. #number + +-- Haskell types must start with an uppercase letter, so we capitalize message +-- and enum names. +-- OccNameStr collisions will show up as build errors in the generated haskell file. +capitalize :: Text -> Text +capitalize s + | Just (c, s') <- uncons s = cons (toUpper c) s' + | otherwise = s + +overloadedFieldName :: FieldInfo -> Symbol +overloadedFieldName = overloadedName . fieldName diff --git a/app/Data/ProtoLens/Compiler/Editions/Defaults.hs b/app/Data/ProtoLens/Compiler/Editions/Defaults.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Editions/Defaults.hs @@ -0,0 +1,43 @@ +-- Copyright 2024 Google LLC. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd + +{-| +Module: Data.ProtoLens.Compiler.Editions.Defaults +Description: Exports defaults for native features in Protobuf Editions. +Copyright: Copyright (c) 2024 Google LLC +License: BSD3 +-} +module Data.ProtoLens.Compiler.Editions.Defaults (nativeDefaults) where + +import Data.ByteString (ByteString) +import Data.ProtoLens (decodeMessage) +import Proto.Google.Protobuf.Descriptor (FeatureSetDefaults) + +{-| 'FeatureSetDefaults' message containing feature defaults. + +This contains the defaults from editions @LEGACY@ to @EDITION_2023@ +for the native features defined by @google.protobuf.FeatureSet@. +-} +nativeDefaults :: FeatureSetDefaults +nativeDefaults + | Right m <- msg = m + | Left e <- msg = error $ "unable to decode built-in defaults: " ++ e + where msg = decodeMessage serializedNativeDefaults + +{-| Serialized 'FeatureSetDefaults' message containing feature defaults. + +This contains the defaults from editions @PROTO2@ to @EDITION_2024@ +for the native features defined by @google.protobuf.FeatureSet@. +The message was generated with @protoc@ and translated into a Haskell string: + +> $ protoc --edition_defaults_out=defaults.binpb --edition_defaults_minimum=PROTO2 --edition_defaults_maximum=2024 google/protobuf/descriptor.proto +> $ ghci +> ghci> import Data.ByteString as B +> ghci> B.readFile "defaults.binpb" >>= print . show + +-} +serializedNativeDefaults :: ByteString +serializedNativeDefaults = read "\"\\n\\DC3\\CAN\\132\\a\\\"\\NUL*\\f\\b\\SOH\\DLE\\STX\\CAN\\STX \\ETX(\\SOH0\\STX\\n\\DC3\\CAN\\231\\a\\\"\\NUL*\\f\\b\\STX\\DLE\\SOH\\CAN\\SOH \\STX(\\SOH0\\SOH\\n\\DC3\\CAN\\232\\a\\\"\\f\\b\\SOH\\DLE\\SOH\\CAN\\SOH \\STX(\\SOH0\\SOH*\\NUL \\230\\a(\\233\\a\"" diff --git a/app/Data/ProtoLens/Compiler/Editions/Features.hs b/app/Data/ProtoLens/Compiler/Editions/Features.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Editions/Features.hs @@ -0,0 +1,94 @@ +-- Copyright 2024 Google LLC. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd + +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} + +{-| +Module: Data.ProtoLens.Compiler.Editions.Features +Description: Resolves a feature set for a particular edition with Protobuf Editions. +Copyright: Copyright (c) 2024 Google LLC +License: BSD3 +-} +module Data.ProtoLens.Compiler.Editions.Features + ( featuresForEdition + , featuresForEditionFromDefaults + , mergedInto + ) where + +import Control.Applicative ((<|>)) +import Data.ProtoLens (defMessage) +import Data.ProtoLens.Compiler.Editions.Defaults (nativeDefaults) +import Data.ProtoLens.Labels () +import qualified Data.Text as T +import Data.Text (Text) +import Lens.Family2 ((^.), (.~), (&)) +import Proto.Google.Protobuf.Descriptor + ( Edition + , FeatureSet + , FeatureSetDefaults) + +{-| +Returns the native feature set defaults for the given edition. + +Native features refer to the fields directly defined by 'FeatureSet'. +Features defined as extensions of 'FeatureSet' would be custom features. +-} +featuresForEdition :: Edition -> Either Text FeatureSet +featuresForEdition = featuresForEditionFromDefaults nativeDefaults + +{-| +Given the feature set defaults for multiple editions, +return the feature set defaults for the given edition. + +If extensions were supported, this could be used directly +to resolve custom features defined as extensions of 'FeatureSet' +for a particular edition. +-} +featuresForEditionFromDefaults + :: FeatureSetDefaults + -> Edition + -> Either Text FeatureSet +featuresForEditionFromDefaults defaults edition + | (d : _) <- candidates = + Right $ (d ^. #overridableFeatures) `mergedInto` (d ^. #fixedFeatures) + | otherwise = + Left $ "Unsupported edition. Tag number: " <> (T.pack . show . fromEnum) edition + where + candidates = dropWhile (\d -> d ^. #edition > edition) recentFirst + + -- #defaults is supposed to be in ascending order of editions + recentFirst = reverse $ defaults ^. #defaults + +{-| +Returns the result of merging a 'FeatureSet' message into another 'FeatureSet' message. + +The semantics are the same as @MergeFrom@ in C++. +When merging a message A into a message B, then any field that has a value in A +will override the value of the same field in B, +otherwise the field in B is used as is. + +Consider using this function as an infix operator. +For example, + +>>> let c = a `mergedInto` b + +could be read like "message C is the message A merged into message B". + +If merging was generally supported for all messages, +we would use it directly instead of using this custom implementation for 'FeatureSet'. +This does not support merging extensions or unknown fields. +-} +mergedInto :: FeatureSet -- ^ Feature set to merge from. + -> FeatureSet -- ^ Feature set to merge into. + -> FeatureSet -- ^ The merged feature set. +mergedInto a b = defMessage + & #maybe'fieldPresence .~ (a ^. #maybe'fieldPresence <|> b ^. #maybe'fieldPresence) + & #maybe'enumType .~ (a ^. #maybe'enumType <|> b ^. #maybe'enumType) + & #maybe'repeatedFieldEncoding .~ (a ^. #maybe'repeatedFieldEncoding <|> b ^. #maybe'repeatedFieldEncoding) + & #maybe'utf8Validation .~ (a ^. #maybe'utf8Validation <|> b ^. #maybe'utf8Validation) + & #maybe'messageEncoding .~ (a ^. #maybe'messageEncoding <|> b ^. #maybe'messageEncoding) + & #maybe'jsonFormat .~ (a ^. #maybe'jsonFormat <|> b ^. #maybe'jsonFormat) diff --git a/app/Data/ProtoLens/Compiler/Generate.hs b/app/Data/ProtoLens/Compiler/Generate.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Generate.hs @@ -0,0 +1,1108 @@ +-- Copyright 2016 Google Inc. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd + +-- | This module builds the actual, generated Haskell file +-- for a given input .proto file. +{-# LANGUAGE CPP #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} +module Data.ProtoLens.Compiler.Generate( + generateModule, + ) where + + +import Control.Arrow (second) +import qualified Data.Foldable as F +import qualified Data.List as List +import qualified Data.Map as Map +import Data.Maybe (isJust) +#if !MIN_VERSION_base(4,11,0) +import Data.Semigroup ((<>)) +#endif +import Data.Ord (comparing) +import qualified Data.Set as Set +import Data.String (fromString) +import Data.Text (unpack) +import qualified Data.Text as T +import Data.Tuple (swap) +import GHC.SourceGen +#if MIN_VERSION_ghc(8,10,0) +import GHC.Hs (ideclName, ideclAs) +#else +import HsSyn (ideclName, ideclAs) +#endif +#if MIN_VERSION_ghc(9,10,0) +import GHC.Parser.Annotation (noAnn) +#elif MIN_VERSION_ghc(9,2,0) +import GHC.Parser.Annotation (EpAnn(EpAnnNotUsed), SrcSpanAnn'(SrcSpanAnn)) +#endif +#if MIN_VERSION_ghc(9,0,0) +#if MIN_VERSION_ghc(9,6,0) +import Language.Haskell.Syntax.Module.Name (moduleNameString, mkModuleName) +#else +import GHC.Unit.Module.Name (moduleNameString, mkModuleName) +#endif +import qualified GHC.Utils.Outputable as Outputable +import GHC.Types.SrcLoc (unLoc) +import qualified GHC.Types.SrcLoc as SrcLoc +#else +import Module (moduleNameString, mkModuleName) +import qualified Outputable +import SrcLoc (unLoc) +import qualified SrcLoc +#endif +import Lens.Family2 ((^.)) +import Text.Printf (printf) + +import Proto.Google.Protobuf.Descriptor + ( EnumValueDescriptorProto + , FileDescriptorProto + , FieldDescriptorProto + , FieldDescriptorProto'Type(..) + ) + +import Data.ProtoLens.Compiler.Definitions +import Data.ProtoLens.Compiler.Generate.Commented +import Data.ProtoLens.Compiler.Generate.Encoding +import Data.ProtoLens.Compiler.Generate.Field + ( hsFieldType + , hsFieldVectorType + ) + +import Data.ProtoLens.Encoding (encodeMessage) +import qualified Data.ByteString as BS + +-- Whether to import the "Runtime" modules or the originals; +-- e.g., Data.ProtoLens.Runtime.Data.Map vs Data.Map. +data UseRuntime = UseRuntime | UseOriginal + deriving (Eq, Read) + +-- | Generate a Haskell module for the given input file(s). +-- input contains all defined names, incl. those in this module +generateModule :: ModuleNameStr + -> FileDescriptorProto -- ^ The complete file descriptor + -> [ModuleNameStr] -- ^ The imported modules + -> [ModuleNameStr] -- ^ The publicly imported modules + -> Env OccNameStr -- ^ Definitions in this file + -> Env RdrNameStr -- ^ Definitions in the imported modules + -> [ServiceInfo] + -> [CommentedModule] +generateModule modName fdesc imports publicImports definitions importedEnv services + = [ CommentedModule pragmas + (module' (Just modName) + (Just $ serviceExports + ++ concatMap generateExports (Map.elems definitions) + ++ map moduleContents publicImports) + (mainImports ++ sharedImports + ++ map importQualified (imports List.\\ publicImports) + ++ map import' publicImports) + []) + $ concatMap generateDecls (Map.toList definitions) + ++ map uncommented (concatMap (generateServiceDecls env) services) + ++ map uncommented packedFileDescriptorProto + , CommentedModule pragmas + (module' (Just fieldModName) Nothing + (sharedImports ++ map importQualified imports) []) + $ map uncommented + $ concatMap generateFieldDecls allLensNames + ] + where + fieldModName = fromString $ moduleNameString (unModuleNameStr modName) ++ "_Fields" + pragmas = + [ languagePragma $ List.intercalate ", " $ map fromString + ["ScopedTypeVariables", "DataKinds", "TypeFamilies", + "UndecidableInstances", "GeneralizedNewtypeDeriving", + "MultiParamTypeClasses", "FlexibleContexts", "FlexibleInstances", + "PatternSynonyms", "MagicHash", "NoImplicitPrelude", + "DataKinds", "BangPatterns", "TypeApplications", + "OverloadedStrings", "DerivingStrategies"] + -- Allow unused imports in case we don't import anything from + -- Data.Text, Data.Int, etc. + , optionsGhcPragma "-Wno-unused-imports" + -- haskell-src-exts doesn't support exporting `Foo(..., A, B)` + -- in a single entry, so we use two: `Foo(..)` and `Foo(A, B)`. + , optionsGhcPragma "-Wno-duplicate-exports" + -- Don't warn if empty "import public" modules are reexported. + , optionsGhcPragma "-Wno-dodgy-exports" + ] + mainImports = map (reexported . importQualified) + [ "Control.DeepSeq", "Data.ProtoLens.Prism" ] + sharedImports = map (reexported . importQualified) + [ "Prelude", "Data.Int", "Data.Monoid", "Data.Word" + , "Data.ProtoLens" + , "Data.ProtoLens.Encoding.Bytes" + , "Data.ProtoLens.Encoding.Growing" + , "Data.ProtoLens.Encoding.Parser.Unsafe" + , "Data.ProtoLens.Encoding.Wire" + , "Data.ProtoLens.Field" + , "Data.ProtoLens.Message.Enum" + , "Data.ProtoLens.Service.Types" + , "Lens.Family2", "Lens.Family2.Unchecked" + , "Data.Text", "Data.Map", "Data.ByteString", "Data.ByteString.Char8" + , "Data.Text.Encoding" + , "Data.Vector" + , "Data.Vector.Generic" + , "Data.Vector.Unboxed" + , "Text.Read" + ] + env = Map.union (unqualifyEnv definitions) importedEnv + generateDecls (protoName, Message m) + = generateMessageDecls fieldModName env (stripDotPrefix protoName) m + ++ map uncommented (concatMap (generatePrisms env) (messageOneofFields m)) + generateDecls (_, Enum e) = map uncommented $ generateEnumDecls e + generateExports (Message m) = generateMessageExports m + ++ concatMap generatePrismExports (messageOneofFields m) + generateExports (Enum e) = generateEnumExports e + serviceExports = fmap generateServiceExports services + allLensNames = F.toList $ Set.fromList + [ lensSymbol inst + | Message m <- Map.elems definitions + , info <- allMessageFields env m + , inst <- recordFieldLenses info + ] + -- The packedFileDescriptorProto is a file level definition that's + -- shared across all message definitions. If there are no + -- messages, it's omitted since it's only used inside of Message + -- instances. + packedFileDescriptorProto + | null [m | Message m <- Map.elems definitions] = [] + | otherwise = [ + typeSig "packedFileDescriptor" $ var "Data.ByteString.ByteString", + valBind "packedFileDescriptor" $ string packedFDesc + ] + where + packedFDesc = fmap (toEnum . fromEnum) . BS.unpack . encodeMessage $ fdesc + -- The Env uses the convention that Message names are prefixed with '.' + -- (since that's how the FileDescriptorProto refers to them). + -- Strip that off when defining MessageDescriptor.messageName. + stripDotPrefix s + | Just ('.', s') <- T.uncons s = s' + | otherwise = s + +allMessageFields :: Env RdrNameStr -> MessageInfo OccNameStr -> [RecordField] +allMessageFields env info = + map (plainRecordField env) (messageFields info) + ++ map (oneofRecordField env) (messageOneofFields info) + +{- We import modules as follows: + +1) Modules from proto-lens-runtime: import qualified, strip the prefix: + import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text + +2) Modules from "import" declarations: import qualified: + import qualified Proto.Foo.Bar + +3) Modules from "import public" declarations: import unqualified: + import Proto.Foo.Bar + To reexport the imported declarations from the current module via + module ... (module Proto.Foo.Bar) + the module Proto.Foo.Bar needs to be unqualified. + Alternately we could explicitly enumerate every definition being reexported, but + that would lead to less readable Haddocks and also make codegen a little more + complicated. +-} + +importQualified :: ModuleNameStr -> ImportDecl' +importQualified = qualified' . import' + +type ModifyImports = ImportDecl' -> ImportDecl' + +reexported :: ModifyImports +reexported imp = imp { ideclName = noLoc m', ideclAs = Just m } + where +#if MIN_VERSION_ghc(9,10,0) + noLoc = SrcLoc.L noAnn +#elif MIN_VERSION_ghc(9,2,0) + noLoc = SrcLoc.L (SrcSpanAnn EpAnnNotUsed SrcLoc.noSrcSpan) +#else + noLoc = SrcLoc.noLoc +#endif + m' = mkModuleName $ "Data.ProtoLens.Runtime." ++ moduleNameString (unLoc m) + m = ideclName imp + +messageComment :: ModuleNameStr -> OccNameStr -> [RecordField] -> Outputable.SDoc +messageComment fieldModName n fields = + Outputable.vcat + $ [Outputable.text "Fields :", ""] + ++ map item (concatMap recordFieldLenses fields) + where + item :: LensInstance -> Outputable.SDoc + item l = Outputable.text (printf " * '%s.%s' @:: " + (moduleNameStrToString fieldModName) + (occNameStrToString $ nameFromSymbol $ lensSymbol l)) + Outputable.<> + Outputable.ppr (var "Lens'" @@ t @@ lensFieldType l) + Outputable.<> Outputable.char '@' + t = var (unqual n) + +generateMessageExports :: MessageInfo OccNameStr -> [IE'] +generateMessageExports m = + -- Hide the message contructor, but expose "oneof" case constructors. + thingWith (unqual $ messageName m) [] + : map (thingAll . unqual . oneofTypeName) + (messageOneofFields m) + +generateServiceDecls :: Env RdrNameStr -> ServiceInfo -> [HsDecl'] +generateServiceDecls env si = + -- data MyService = MyService + [ data' serverDataName [] + [ recordCon serverDataName [] + ] + [] + ] ++ + -- instance Data.ProtoLens.Service.Types.Service MyService where + -- type ServiceName MyService = "myService" + -- type ServicePackage MyService = "some.package" + -- type ServiceMethods MyService = '["normalMethod", "streamingMethod"] + -- packedServiceDescriptor _ = ... + [ instance' (var "Data.ProtoLens.Service.Types.Service" @@ serverRecordType) + [ tyFamInst "ServiceName" [serverRecordType] + . stringTy . T.unpack $ serviceName si + , tyFamInst "ServicePackage" [serverRecordType] + . stringTy . T.unpack $ servicePackage si + , tyFamInst "ServiceMethods" [serverRecordType] + $ listPromotedTy + [ stringTy . T.unpack $ methodIdent m + | m <- List.sortBy (comparing methodIdent) $ serviceMethods si + ] + , funBind "packedServiceDescriptor" $ match [wildP] $ string svcDescriptor + ] + ] ++ + -- instance Data.ProtoLens.Service.Types.HasMethodImpl MyService "normalMethod" where + -- type MethodInput MyService "normalMethod" = Foo + -- type MethodOutput MyService "normalMethod" = Bar + -- type IsClientStreaming MyService "normalMethod" = 'False + -- type IsServerStreaming MyService "normalMethod" = 'False + [ instance' (var "Data.ProtoLens.Service.Types.HasMethodImpl" @@ serverRecordType @@ instanceHead) + [ tyFamInst "MethodName" [serverRecordType, instanceHead] + . stringTy . T.unpack $ methodName m + , tyFamInst "MethodInput" [serverRecordType, instanceHead] + . lookupType $ methodInput m + , tyFamInst "MethodOutput" [serverRecordType, instanceHead] + . lookupType $ methodOutput m + , tyFamInst "MethodStreamingType" [serverRecordType, instanceHead] + . tyPromotedVar + $ case (methodClientStreaming m, methodServerStreaming m) of + (False, False) -> "Data.ProtoLens.Service.Types.NonStreaming" + (True, False) -> "Data.ProtoLens.Service.Types.ClientStreaming" + (False, True) -> "Data.ProtoLens.Service.Types.ServerStreaming" + (True, True) -> "Data.ProtoLens.Service.Types.BiDiStreaming" + ] + | m <- serviceMethods si + , let instanceHead = stringTy (T.unpack $ methodIdent m) + ] + where + svcDescriptor = fmap (toEnum . fromEnum) . BS.unpack . encodeMessage $ serviceDescriptor si + serverDataName = fromString . T.unpack $ serviceName si + serverRecordType = var $ unqual serverDataName + + lookupType t = case definedType t env of + Message msg -> var $ messageName msg + Enum _ -> error "Service must have a message type" + + +generateMessageDecls :: ModuleNameStr -> Env RdrNameStr -> T.Text -> MessageInfo OccNameStr -> [CommentedDecl] +generateMessageDecls fieldModName env protoName info = + -- data Bar = Bar { + -- foo :: Baz + -- } + [ commented (messageComment fieldModName (messageName info) allFields) + $ data' dataName [] + [recordCon (messageConstructorName info) $ + [ (recordFieldName f, strict $ field $ recordFieldType f) + | f <- allFields + ] + ++ [(messageUnknownFields info, strict $ field $ var "Data.ProtoLens.FieldSet")] + ] + [derivingStock [var "Prelude.Eq", var "Prelude.Ord"]] + -- instance Show Bar where + -- showsPrec __x __s = showChar '{' (showString (showMessageShort __x) (showChar '}' s)) + , uncommented $ + instance' (var "Prelude.Show" @@ dataType) + [funBind "showsPrec" $ match [bvar "_", bvar "__x", bvar "__s"] + $ var "Prelude.showChar" @@ char '{' + @@ (var "Prelude.showString" + @@ (var "Data.ProtoLens.showMessageShort" @@ var "__x") + @@ (var "Prelude.showChar" @@ char '}' @@ var "__s"))] + ] ++ + -- oneof field data type declarations + -- proto: message Foo { + -- oneof bar { + -- float c = 1; + -- Sub s = 2; + -- } + -- } + -- haskell: data Foo'Bar = Foo'Bar'c !Prelude.Float + -- | Foo'Bar's !Sub + [ uncommented $ data' (oneofTypeName oneofInfo) [] + [ prefixCon consName [strict $ field $ hsFieldType env f] + | c <- oneofCases oneofInfo + , let f = caseField c + , let consName = caseConstructorName c + ] + [derivingStock [var "Prelude.Show", var "Prelude.Eq", var "Prelude.Ord"]] + | oneofInfo <- messageOneofFields info + ] ++ + -- instance HasField Foo "foo" Bar + -- fieldOf _ = ... + -- Note: for optional fields, this generates an instance both for "foo" and + -- for "maybe'foo" (see plainRecordField below). + [ uncommented $ instance' + (var "Data.ProtoLens.Field.HasField" @@ dataType @@ sym @@ t) + [funBind "fieldOf" $ match [wildP] $ + var "Prelude.." + @@ rawFieldAccessor (unqual $ recordFieldName li) + @@ lensExp i] + | li <- allFields + , i <- recordFieldLenses li + , let t = lensFieldType i + , let sym = promoteSymbol $ lensSymbol i + ] + ++ + -- instance Message.Message Bar where + [ uncommented $ instance' (var "Data.ProtoLens.Message" @@ dataType) + $ messageInstance env protoName info + -- instance NFData Bar where + , uncommented $ instance' (var "Control.DeepSeq.NFData" @@ dataType) + [valBind "rnf" $ messageRnfExpr info] + ] ++ + -- instance NFData Foo'Bar where + [ uncommented $ + instance' (var "Control.DeepSeq.NFData" @@ + var (unqual $ oneofTypeName o)) + [funBinds "rnf" $ map oneofRnfMatch $ oneofCases o] + | o <- messageOneofFields info + ] + where + dataType = var $ unqual dataName + dataName = messageName info + allFields = allMessageFields env info + +-- oneof Prism declarations +-- proto: message Foo { +-- oneof bar { +-- float c = 1; +-- Sub s = 2; +-- } +-- } +-- haskell: _Foo'C :: Prism' Bar'C Float +-- _Foo'S :: Prism' Bar'S Sub +-- +-- example of the function definition for _Foo'C: +-- _Foo'C :: Prism' Bar'C Float +-- _Foo'C +-- = prism' Bar'C +-- (\ p__ -> +-- case p__ of +-- Bar'C p__val -> Prelude.Just p__val +-- _otherwise -> Prelude.Nothing) +generatePrisms :: Env RdrNameStr -> OneofInfo -> [HsDecl'] +generatePrisms env oneofInfo = + if length cases > 1 + then concatMap (generatePrism altOtherwise) cases + else concatMap (generatePrism mempty) cases + where + cases = oneofCases oneofInfo + altOtherwise = [match [bvar "_otherwise"] (var "Prelude.Nothing")] + + -- Generate type signature + -- e.g. Prism' Bar'C Float + generateTypeSig f funName = + typeSig funName $ var "Data.ProtoLens.Prism.Prism'" + -- The oneof sum type name + @@ (var . unqual $ oneofTypeName oneofInfo) + -- The field contained in the sum + @@ hsFieldType env f + -- Generate function definition + -- Prism' is constructed with Constructor for building value + -- and Deconstructor and wrapping in Just for getting value + generateFunDef :: [RawMatch] -> OccNameStr -> HsExpr' + generateFunDef otherwiseCase consName = + var "Data.ProtoLens.Prism.prism'" + -- Sum type constructor + @@ var (unqual consName) + -- Case deconstruction + @@ lambda [bvar "p__"] ( + case' (var "p__") $ + match [conP (unqual consName) [bvar "p__val"]] + (var "Prelude.Just" @@ var "p__val") + -- We want to generate the otherwise case + -- depending on the amount of sum type cases there are + : otherwiseCase + ) + generatePrism :: [RawMatch] -> OneofCase -> [HsDecl'] + generatePrism otherwiseCase oneofCase = + let consName = caseConstructorName oneofCase + prismName = casePrismName oneofCase + in [ generateTypeSig (caseField oneofCase) prismName + , valBind prismName $ generateFunDef otherwiseCase consName + ] + +generatePrismExports :: OneofInfo -> [IE'] +generatePrismExports = map (var . unqual . casePrismName) . oneofCases + +generateEnumExports :: EnumInfo OccNameStr -> [IE'] +generateEnumExports e = [thingAll n, thingWith n aliases] ++ proto3NewType + where + n = unqual $ enumName e + aliases = [enumValueName v | v <- enumValues e, needsManualExport v] + needsManualExport v = isJust (enumAliasOf v) + proto3NewType = case enumUnrecognized e of + Just u -> [var . unqual $ unrecognizedValueName u] + Nothing -> [] + +generateServiceExports :: ServiceInfo -> IE' +generateServiceExports si = thingAll $ unqual $ fromString $ T.unpack $ serviceName si + +generateEnumDecls :: EnumInfo OccNameStr -> [HsDecl'] +generateEnumDecls info = + -- Proto3-only: + -- newtype FooEnum'UnrecognizedValue = FooEnum'UnrecognizedValue Data.Int.Int32 + -- deriving (Prelude.Eq, Prelude.Ord, Prelude.Show, Prelude.Read) + [ newtype' (unrecognizedValueName u) [] + (prefixCon (unrecognizedValueName u) [field $ var "Data.Int.Int32"]) + [derivingStock [var "Prelude.Eq", var "Prelude.Ord", var "Prelude.Show"]] + | Just u <- [unrecognized] + ] + ++ + + -- data FooEnum + -- = Enum1 + -- | Enum2 + -- | FooEnum'Unrecognized !FooEnum'UnrecognizedValue + -- deriving (Prelude.Show, Prelude.Eq, Prelude.Ord, Prelude.Read) + [ data' dataName [] + ( (flip prefixCon [] <$> constructorNames) + ++ [ prefixCon (unrecognizedName u) + [strict $ field $ var $ unqual $ unrecognizedValueName u] + | Just u <- [unrecognized] + ] + ) + [derivingStock [var "Prelude.Show", var "Prelude.Eq", var "Prelude.Ord"]] + + -- instance Data.ProtoLens.MessageEnum FooEnum where + -- maybeToEnum 0 = Prelude.Just Enum1 + -- maybeToEnum 3 = Prelude.Just Enum2 + -- maybeToEnum k + -- -- Proto3: + -- = Prelude.Just + -- (FooEnum'Unrecognized + -- (FooEnum'UnrecognizedValue (Prelude.fromIntegral k))) + -- -- Proto2: + -- = Nothing + -- + -- showEnum Foo'Enum2 = "Enum2" + -- showEnum Foo'Enum1 = "Enum1" + -- showEnum (FooEnum'Unrecognized (FooEnum'UnrecognizedValue k)) + -- = Prelude.show k + -- + -- readEnum k + -- | k == "Enum2a" = Prelude.Just Enum2a -- alias + -- | k == "Enum2" = Prelude.Just Enum2 + -- | k == "Enum1" = Prelude.Just Enum1 + -- readEnum k = Text.Read.readMaybe k >>= maybeToEnum + , instance' (var "Data.ProtoLens.MessageEnum" @@ dataType) + [ funBinds "maybeToEnum" $ + [ match [int k] $ var "Prelude.Just" @@ var (unqual c) + | (c, k) <- constructorNumbers + ] + ++ + [ case enumUnrecognized info of + Nothing -> match [wildP] $ var "Prelude.Nothing" + Just u -> match [bvar "k"] + $ var "Prelude.Just" @@ + (var (unqual $ unrecognizedName u) + @@ (var (unqual $ unrecognizedValueName u) + @@ (var "Prelude.fromIntegral" @@ var "k") + ) + ) + ] + , funBinds "showEnum" $ + [ match [conP_ (unqual n)] $ string pn + | v <- filter (null . enumAliasOf) $ enumValues info + , let n = enumValueName v + , let pn = T.unpack $ enumValueDescriptor v ^. #name + ] ++ + [ match [conP (unqual $ unrecognizedName u) + [conP (unqual $ unrecognizedValueName u) [bvar "k"]] + ] + $ var "Prelude.show" @@ var "k" + | Just u <- [unrecognized] + ] + , funBind "readEnum" $ matchGRHSs [bvar "k"] $ guardedRhs $ + [ guard (var "Prelude.==" @@ var "k" @@ string pn) + $ var "Prelude.Just" @@ var (unqual n) + | v <- enumValues info + , let n = enumValueName v + , let pn = T.unpack $ enumValueDescriptor v ^. #name + ] + ++ [guard (var "Prelude.otherwise") $ var "Prelude.>>=" + @@ (var "Text.Read.readMaybe" @@ var "k") + @@ var "Data.ProtoLens.maybeToEnum"] + ] + + -- instance Bounded Foo where + -- minBound = Foo1 + -- maxBound = FooN + , instance' (var "Prelude.Bounded" @@ dataType) + [ valBind "minBound" $ var $ unqual minBoundName + , valBind "maxBound" $ var $ unqual maxBoundName + ] + + -- instance Enum Foo where + -- toEnum k = maybe (error ("Foo.toEnum: unknown argument for enum Foo: " + -- ++ show k)) + -- id (maybeToEnum k) + -- fromEnum Foo1 = 1 + -- fromEnum Foo2 = 2 + -- .. + -- succ FooN = error "Foo.succ: bad argument FooN." + -- succ Foo1 = Foo2 + -- succ Foo2 = Foo3 + -- .. + -- pred Foo1 = error "Foo.succ: bad argument Foo1." + -- pred Foo2 = Foo1 + -- pred Foo3 = Foo2 + -- .. + -- enumFrom = messageEnumFrom + -- enumFromTo = messageEnumFromTo + -- enumFromThen = messageEnumFromThen + -- enumFromThenTo = messageEnumFromThenTo + , instance' (var "Prelude.Enum" @@ dataType) + [funBind "toEnum" $ match [bvar "k__"] + $ var "Prelude.maybe" @@ errorMessageExpr @@ var "Prelude.id" + @@ (var "Data.ProtoLens.maybeToEnum" @@ var "k__") + , funBinds "fromEnum" $ + [ match [conP_ (unqual c)] $ int k + | (c, k) <- constructorNumbers + ] + ++ + [ match [conP (unqual $ unrecognizedName u) + [conP (unqual $ unrecognizedValueName u) [bvar "k"]] + ] + $ var "Prelude.fromIntegral" @@ var "k" + | Just u <- [unrecognized] + ] + , succDecl "succ" maxBoundName succPairs + , succDecl "pred" minBoundName $ map swap succPairs + , valBind "enumFrom" $ var "Data.ProtoLens.Message.Enum.messageEnumFrom" + , valBind "enumFromTo" $ var "Data.ProtoLens.Message.Enum.messageEnumFromTo" + , valBind "enumFromThen" $ var "Data.ProtoLens.Message.Enum.messageEnumFromThen" + , valBind "enumFromThenTo" + $ var "Data.ProtoLens.Message.Enum.messageEnumFromThenTo" + ] + + -- instance Data.ProtoLens.FieldDefault Foo where + -- fieldDefault = FirstEnumValue + , instance' (var "Data.ProtoLens.FieldDefault" @@ dataType) + [valBind "fieldDefault" defaultCon] + + -- instance NFData Foo where + -- rnf x__ = seq x__ () + -- (Trivial since enum types are already strict) + , instance' (var "Control.DeepSeq.NFData" @@ dataType) + [ funBind "rnf" $ match [bvar "x__"] + $ var "Prelude.seq" @@ var "x__" @@ var "()" ] + ] ++ + + -- pattern Enum2a :: FooEnum + -- pattern Enum2a = Enum2 + concat + [ [ patSynSig aliasName dataType + , patSynBind aliasName [] (bvar originalName) + ] + | EnumValueInfo + { enumValueName = aliasName + , enumAliasOf = Just originalName + } <- enumValues info + ] + + where + EnumInfo { enumName = dataName + , enumUnrecognized = unrecognized + , enumDescriptor = ed + } = info + errorMessage = "toEnum: unknown value for enum " ++ unpack (ed ^. #name) + ++ ": " + + errorMessageExpr = var "Prelude.error" + @@ (var "Prelude.++" @@ string errorMessage + @@ (var "Prelude.show" @@ var "k__")) + + dataType = var $ unqual dataName + + constructors :: [(OccNameStr, EnumValueDescriptorProto)] + constructors = List.sortBy (comparing ((^. #number) . snd)) + [(n, d) | EnumValueInfo + { enumValueName = n + , enumValueDescriptor = d + , enumAliasOf = Nothing + } <- enumValues info + ] + constructorNames = map fst constructors + + defaultCon = var $ unqual minBoundName + + (minBoundName, maxBoundName, succPairs) = + case constructorNames of + (c : cs) -> (c, last constructorNames, zip constructorNames cs) + _ -> error $ "Unexpected empty constructors in " <> show (enumName info) + + constructorNumbers = map (second (fromIntegral . (^. #number))) constructors + + succDecl :: OccNameStr -> OccNameStr -> [(OccNameStr, OccNameStr)] -> RawInstDecl + succDecl funName boundName thePairs = funBinds funName $ + match [conP_ (unqual boundName)] + (var "Prelude.error" @@ string (concat + [ occNameStrToString dataName, "." + , occNameStrToString funName, ": bad argument " + , occNameStrToString boundName + , ". This value would be out of bounds." + ])) + : + [ match [conP_ (unqual from')] $ var $ unqual to + | (from', to) <- thePairs + ] + ++ + [ match [conP (unqual $ unrecognizedName u) [wildP]] + (var "Prelude.error" @@ string (concat + [ occNameStrToString dataName, "." + , occNameStrToString funName, ": bad argument: unrecognized value" + + ])) + | Just u <- [unrecognized] + ] + +generateFieldDecls :: Symbol -> [HsDecl'] +generateFieldDecls xStr = + -- foo :: forall f s a + -- . (Functor f, HasLens s x a) => LensLike' f s a + -- foo = fieldOf @s + [ typeSig x + $ forall' [bvar "f", bvar "s", bvar "a"] + $ [ var "Prelude.Functor" @@ var "f" + , var "Data.ProtoLens.Field.HasField" @@ var "s" @@ xSym @@ var "a" + ] + ==> var "Lens.Family2.LensLike'" @@ var "f" @@ var "s" @@ var "a" + , valBind x $ fieldOfExp xStr + ] + where + x = nameFromSymbol xStr + xSym = promoteSymbol xStr + +------------------------------------------ + +-- | An individual field of the Haskell type corresponding to a proto message. +data RecordField = RecordField + { recordFieldName :: OccNameStr -- ^ The Haskell name of this field (unique + -- within the module). + , recordFieldType :: HsType' -- ^ Internal type in the record + , recordFieldLenses :: [LensInstance] + -- ^ All of the (overloaded) lenses accessing this record field. + } + +-- | An instance of HasLens' for a particular field. +data LensInstance = LensInstance + { lensSymbol :: Symbol + -- ^ The overloaded name for this lens. + , lensFieldType :: HsType' + -- ^ The type pointed to from this lens. + , lensExp :: HsExpr' + -- ^ A lens from the recordFieldType to the lensFieldType; i.e., + -- from how it's actually stored in the Haskell record to how the + -- lens views it. + } + +-- | Compile information about the record field type and type/class instances +-- for this particular field. +-- +-- Used for "plain" record fields that are not part of a oneof. +plainRecordField :: Env RdrNameStr -> PlainFieldInfo -> RecordField +plainRecordField env (PlainFieldInfo kind f) = case kind of + -- data Foo = Foo { _Foo_bar :: Bar } + -- type instance Field "bar" Foo = Bar + RequiredField + -> recordField baseType + [LensInstance + { lensSymbol = baseName + , lensFieldType = baseType + , lensExp = rawAccessor + }] + OptionalValueField + -> recordField baseType + [LensInstance + { lensSymbol = baseName + , lensFieldType = baseType + , lensExp = rawAccessor + }] + -- data Foo = Foo { _Foo_bar :: Maybe Bar } + -- type instance Field "bar" Foo = Bar + -- type instance Field "maybe'bar" Foo = Maybe Bar + OptionalMaybeField -> + recordField maybeType + [LensInstance + { lensSymbol = baseName + , lensFieldType = baseType + , lensExp = maybeAccessor + } + , LensInstance + { lensSymbol = "maybe'" <> baseName + , lensFieldType = maybeType + , lensExp = rawAccessor + } + ] + -- data Foo = Foo { _Foo_bar :: Map Bar Baz } + -- type instance Field "foo" Foo = Map Bar Baz + MapField entry -> + let mapType = var "Data.Map.Map" + @@ hsFieldType env (keyField entry) + @@ hsFieldType env (valueField entry) + in recordField mapType + [LensInstance + { lensSymbol = baseName + , lensFieldType = mapType + , lensExp = rawAccessor + }] + -- data Foo = Foo { _Foo_bar :: [Bar] } + -- type instance Field "bar" Foo = [Bar] + RepeatedField {} -> + recordField vectorType + [ LensInstance + { lensSymbol = baseName + , lensFieldType = listType + , lensExp = vectorAccessor + } + , LensInstance + { lensSymbol = "vec'" <> baseName + , lensFieldType = vectorType + , lensExp = rawAccessor + } + ] + where + recordField = RecordField (haskellRecordFieldName $ fieldName f) + baseName = overloadedName $ fieldName f + fd = fieldDescriptor f + baseType = hsFieldType env f + maybeType = var "Prelude.Maybe" @@ baseType + listType = listTy baseType + vectorType = hsFieldVectorType f @@ baseType + rawAccessor = var "Prelude.id" + maybeAccessor = var "Data.ProtoLens.maybeLens" + @@ hsFieldValueDefault env fd + +vectorAccessor :: HsExpr' +vectorAccessor = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter + where + getter = var "Data.Vector.Generic.toList" + setter = lambda [wildP, bvar "y__"] + $ var "Data.Vector.Generic.fromList" @@ var "y__" + +oneofRecordField :: Env RdrNameStr -> OneofInfo -> RecordField +oneofRecordField env oneofInfo + = RecordField + { recordFieldName = haskellRecordFieldName $ oneofFieldName oneofInfo + , recordFieldType = + var "Prelude.Maybe" @@ var (unqual $ oneofTypeName oneofInfo) + , recordFieldLenses = lenses + } + where + lenses = + -- Only generate a "maybe" version of this lens, + -- since oneofs don't have a notion of a "default" case. + -- data Foo = Foo { _Foo'bar = Maybe Foo'Bar } + -- type instance Field "maybe'bar" Foo = Maybe Foo'Bar + LensInstance + { lensSymbol = "maybe'" <> overloadedName + (oneofFieldName oneofInfo) + , lensFieldType = + var "Prelude.Maybe" @@ var (unqual $ oneofTypeName oneofInfo) + , lensExp = var "Prelude.id" + } + : concat + -- Generate the same lenses for each sub-field of the oneof + -- as if they were proto2 optional fields. + -- type instance Field "bar" Foo = Bar + -- type instance Field "maybe'bar" Foo = Maybe Bar + [ [ LensInstance + { lensSymbol = maybeName + , lensFieldType = var "Prelude.Maybe" @@ baseType + , lensExp = oneofFieldAccessor c + } + , LensInstance + { lensSymbol = baseName + , lensFieldType = baseType + , lensExp = var "Prelude.." + @@ oneofFieldAccessor c + @@ (var "Data.ProtoLens.maybeLens" + @@ hsFieldValueDefault env + (fieldDescriptor f)) + } + ] + | c <- oneofCases oneofInfo + , let f = caseField c + , let baseName = overloadedName $ fieldName f + , let baseType = hsFieldType env f + , let maybeName = "maybe'" <> baseName + ] + +hsFieldDefault :: Env RdrNameStr -> PlainFieldInfo -> HsExpr' +hsFieldDefault env f = case plainFieldKind f of + RequiredField -> hsFieldValueDefault env fd + OptionalValueField -> hsFieldValueDefault env fd + OptionalMaybeField -> var "Prelude.Nothing" + MapField {} -> var "Data.Map.empty" + RepeatedField {} -> var "Data.Vector.Generic.empty" + where + fd = fieldDescriptor (plainFieldInfo f) + +hsFieldValueDefault :: Env RdrNameStr -> FieldDescriptorProto -> HsExpr' +hsFieldValueDefault env fd = case fd ^. #type' of + FieldDescriptorProto'TYPE_MESSAGE -> var "Data.ProtoLens.defMessage" + FieldDescriptorProto'TYPE_GROUP -> var "Data.ProtoLens.defMessage" + FieldDescriptorProto'TYPE_ENUM + | T.null def -> var "Data.ProtoLens.fieldDefault" + | Enum e <- definedFieldType fd env + , Just v <- List.lookup def [ (enumValueDescriptor v ^. #name, enumValueName v) + | v <- enumValues e + ] + -> var v + | otherwise -> errorMessage "enum" + -- The rest of the cases are for scalar fields that have a fieldDefault + -- instance. + _ | T.null def -> var "Data.ProtoLens.fieldDefault" + FieldDescriptorProto'TYPE_BOOL + | def == "true" -> var "Prelude.True" + | def == "false" -> var "Prelude.False" + | otherwise -> errorMessage "bool" + FieldDescriptorProto'TYPE_STRING + -> var "Data.Text.pack" @@ string (T.unpack def) + FieldDescriptorProto'TYPE_BYTES + -> var "Data.ByteString.pack" + @@ list (mkByte . fromEnum <$> T.unpack def) + where mkByte c + | c > 0 && c < 255 = int $ fromIntegral c + | otherwise = errorMessage "bytes" + FieldDescriptorProto'TYPE_FLOAT -> defaultFrac $ T.unpack def + FieldDescriptorProto'TYPE_DOUBLE -> defaultFrac $ T.unpack def + -- Otherwise, assume it's an integral field: + _ -> defaultInt $ T.unpack def + where + def = fd ^. #defaultValue + errorMessage fieldType + = error $ "Bad default value " ++ show (T.unpack def) + ++ " in default value for " ++ fieldType ++ " field " + ++ unpack (fd ^. #name) + -- float/double fields can use nan, inf and -inf as default values. + -- The Prelude doesn't provide names for them, so we implement + -- them as division by zero. + defaultFrac "nan" = var "Prelude./" @@ frac 0 @@ frac 0 + defaultFrac "inf" = var "Prelude./" @@ frac 1 @@ frac 0 + defaultFrac "-inf" = var "Prelude./" @@ frac (negate 1) @@ frac 0 + defaultFrac s = case reads s of + [(x, "")] -> frac $ toRational (x :: Double) + _ -> errorMessage "fractional" + defaultInt s = case reads s of + [(x, "")] -> int x + _ -> errorMessage "integral" + +-- | A lens to access an internal field. +-- +-- lens _Foo_bar (\x__ y__ -> x__ { _Foo_bar = y__ }) +rawFieldAccessor :: RdrNameStr -> HsExpr' +rawFieldAccessor f = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter + where + getter = var f + setter = lambda [bvar "x__", bvar "y__"] + $ recordUpd (var "x__") [(f, var "y__")] + +-- | A lens that maps from a oneof sum type to one of its individual cases. +-- +-- For example, with +-- data Foo = Bar Int32 | Baz Int64 +-- +-- this will generate a lens of type @Lens' (Maybe Foo) (Maybe Int32)@. +-- +-- (Recall that oneofs are stored in a proto message as @Maybe Foo@, where +-- 'Nothing' means that it's either set to an unknown value or unset.) +-- +-- lens +-- (\ x__ -> case x__ of +-- Prelude.Just (Foo'c x__val) -> Prelude.Just x__val +-- otherwise -> Prelude.Nothing) +-- (\ _ y__ -> fmap Foo'c y__ +oneofFieldAccessor :: OneofCase -> HsExpr' +oneofFieldAccessor o + = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter + where + consName = caseConstructorName o + getter = lambda [bvar "x__"] $ + case' (var "x__") + [ match [conP "Prelude.Just" [conP (unqual consName) [bvar "x__val"]]] + $ var "Prelude.Just" @@ var "x__val" + , match [bvar "_otherwise"] $ var "Prelude.Nothing" + ] + setter = lambda [wildP, bvar "y__"] + $ var "Prelude.fmap" @@ var (unqual consName) @@ var "y__" + +messageInstance :: Env RdrNameStr -> T.Text -> MessageInfo OccNameStr -> [RawInstDecl] +messageInstance env protoName m = + [ funBind "messageName" $ match [wildP] $ + var "Data.Text.pack" @@ string (T.unpack protoName) + , funBind "packedMessageDescriptor" $ match [wildP] $ string msgDescriptor + , funBind "packedFileDescriptor" $ match [wildP] $ var "packedFileDescriptor" + , valBind "fieldsByTag" $ + let' (map (fieldDescriptorVarBind $ messageName m) fields) + $ var "Data.Map.fromList" @@ list fieldsByTag + , valBind "unknownFields" + $ rawFieldAccessor (unqual $ messageUnknownFields m) + , valBind "defMessage" + $ recordConE (unqual $ messageConstructorName m) $ + [ (unqual $ haskellRecordFieldName + $ fieldName $ plainFieldInfo f, + hsFieldDefault env f) + | f <- messageFields m + ] ++ + [ (unqual $ haskellRecordFieldName $ oneofFieldName o, + var "Prelude.Nothing") + | o <- messageOneofFields m + ] ++ + [ (unqual $ messageUnknownFields m, var "[]")] + , valBind "parseMessage" $ generatedParser env m + , valBind "buildMessage" $ generatedBuilder m + ] + where + msgDescriptor = fmap (toEnum . fromEnum) . BS.unpack . encodeMessage $ messageDescriptor m + fieldsByTag = + [tuple + [ t, fieldDescriptorVar f ] + | f <- fields + , let t = var "Data.ProtoLens.Tag" + @@ int (fromIntegral + $ fieldDescriptor (plainFieldInfo f) ^. #number) + ] + fieldDescriptorVar = var . unqual . fieldDescriptorName + fieldDescriptorName f + = nameFromSymbol $ overloadedName (fieldName . plainFieldInfo $ f) + <> "__field_descriptor" + fieldDescriptorVarBind n f + = valBind (fieldDescriptorName f) + $ fieldDescriptorExpr env n f + fields = messageFields m + ++ (messageOneofFields m >>= fmap casePlainField . oneofCases) + -- The cases of an optional are always treated like proto2 "maybe" fields. + -- This code here does not apply to proto3 optional fields which + -- are absent from messageOneofFields, but those get treated as + -- OptionalMaybeField by fieldKind so they behave the same. + casePlainField = PlainFieldInfo OptionalMaybeField . caseField + +-- | Get the name of the field when used in a text format proto. Groups are +-- special because their text format field name is the name of their type, +-- not the name of the field in the descriptor (e.g. "Foo", not "foo"). +textFormatFieldName :: Env RdrNameStr -> FieldDescriptorProto -> T.Text +textFormatFieldName env descr = case descr ^. #type' of + FieldDescriptorProto'TYPE_GROUP + | Message msg <- definedFieldType descr env + -> messageDescriptor msg ^. #name + | otherwise -> error $ "expected TYPE_GROUP for type name" + ++ T.unpack (descr ^. #typeName) + _ -> descr ^. #name + +fieldDescriptorExpr :: Env RdrNameStr -> OccNameStr -> PlainFieldInfo + -> HsExpr' +fieldDescriptorExpr env n f = + (var "Data.ProtoLens.FieldDescriptor" + -- Record the original .proto name for text format + @@ string (T.unpack $ textFormatFieldName env fd) + -- Force the type signature since it can't be inferred for Map entry + -- types. + @@ (fieldTypeDescriptorExpr (fd ^. #type') + @::@ + (var "Data.ProtoLens.FieldTypeDescriptor" + @@ hsFieldType env (plainFieldInfo f))) + @@ fieldAccessorExpr f) + -- TODO: why is this type sig needed? + @::@ + (var "Data.ProtoLens.FieldDescriptor" @@ var (unqual n)) + where + fd = fieldDescriptor $ plainFieldInfo f + +fieldAccessorExpr :: PlainFieldInfo -> HsExpr' +-- (PlainField Required foo), (OptionalField foo), etc... +fieldAccessorExpr (PlainFieldInfo kind f) = accessorCon @@ fieldOfExp hsFieldName + + where + accessorCon = case kind of + RequiredField + -> var "Data.ProtoLens.PlainField" @@ var "Data.ProtoLens.Required" + OptionalValueField + -> var "Data.ProtoLens.PlainField" @@ var "Data.ProtoLens.Optional" + OptionalMaybeField + -> var "Data.ProtoLens.OptionalField" + MapField entry + -> var "Data.ProtoLens.MapField" + @@ fieldOfExp (overloadedField $ keyField entry) + @@ fieldOfExp (overloadedField $ valueField entry) + RepeatedField packed -> + var "Data.ProtoLens.RepeatedField" + @@ if packed == Packed + then var "Data.ProtoLens.Packed" + else var "Data.ProtoLens.Unpacked" + hsFieldName + = case kind of + OptionalMaybeField -> "maybe'" <> overloadedField f + _ -> overloadedField f + +fieldOfExp :: Symbol -> HsExpr' +fieldOfExp sym = var "Data.ProtoLens.Field.field" `tyApp` promoteSymbol sym + +overloadedField :: FieldInfo -> Symbol +overloadedField = overloadedName . fieldName + +fieldTypeDescriptorExpr :: FieldDescriptorProto'Type -> HsExpr' +fieldTypeDescriptorExpr = \case + FieldDescriptorProto'TYPE_DOUBLE -> mk "ScalarField" "DoubleField" + FieldDescriptorProto'TYPE_FLOAT -> mk "ScalarField" "FloatField" + FieldDescriptorProto'TYPE_INT64 -> mk "ScalarField" "Int64Field" + FieldDescriptorProto'TYPE_UINT64 -> mk "ScalarField" "UInt64Field" + FieldDescriptorProto'TYPE_INT32 -> mk "ScalarField" "Int32Field" + FieldDescriptorProto'TYPE_FIXED64 -> mk "ScalarField" "Fixed64Field" + FieldDescriptorProto'TYPE_FIXED32 -> mk "ScalarField" "Fixed32Field" + FieldDescriptorProto'TYPE_BOOL -> mk "ScalarField" "BoolField" + FieldDescriptorProto'TYPE_STRING -> mk "ScalarField" "StringField" + FieldDescriptorProto'TYPE_GROUP -> mk "MessageField" "GroupType" + FieldDescriptorProto'TYPE_MESSAGE -> mk "MessageField" "MessageType" + FieldDescriptorProto'TYPE_BYTES -> mk "ScalarField" "BytesField" + FieldDescriptorProto'TYPE_UINT32 -> mk "ScalarField" "UInt32Field" + FieldDescriptorProto'TYPE_ENUM -> mk "ScalarField" "EnumField" + FieldDescriptorProto'TYPE_SFIXED32 -> mk "ScalarField" "SFixed32Field" + FieldDescriptorProto'TYPE_SFIXED64 -> mk "ScalarField" "SFixed64Field" + FieldDescriptorProto'TYPE_SINT32 -> mk "ScalarField" "SInt32Field" + FieldDescriptorProto'TYPE_SINT64 -> mk "ScalarField" "SInt64Field" + where + mk x y = var (fromString ("Data.ProtoLens." ++ x)) + @@ var (fromString ("Data.ProtoLens." ++ y)) + +-- | Generate the implementation of NFData.rnf for the given message. +-- +-- instance NFData Bar where +-- rnf = \x -> deepseq (_Bar'foo x) (deepseq (_Bar'bar x) ()) +messageRnfExpr :: MessageInfo OccNameStr -> HsExpr' +messageRnfExpr msg = lambda [bvar "x__"] $ foldr ((@@) . seqField) unit fieldNames + where + fieldNames = messageUnknownFields msg + : map (haskellRecordFieldName . fieldName . plainFieldInfo) + (messageFields msg) + ++ map (haskellRecordFieldName . oneofFieldName) + (messageOneofFields msg) + seqField :: OccNameStr -> HsExpr' + seqField f = var "Control.DeepSeq.deepseq" @@ (var (unqual f) @@ var "x__") + +-- rnf (Foo'a x__) = rnf x__ +-- rnf (Bar'b x__) = rnf x__ +oneofRnfMatch :: OneofCase -> RawMatch +oneofRnfMatch c = match [unqual (caseConstructorName c) `conP` [bvar "x__"]] + $ var "Control.DeepSeq.rnf" @@ var "x__" diff --git a/app/Data/ProtoLens/Compiler/Generate/Commented.hs b/app/Data/ProtoLens/Compiler/Generate/Commented.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Generate/Commented.hs @@ -0,0 +1,62 @@ +{-# LANGUAGE CPP #-} +-- | Enables pretty-printing Haddock comments along with top-level declarations. +module Data.ProtoLens.Compiler.Generate.Commented where + +import GHC.SourceGen +#if MIN_VERSION_ghc(9,0,0) +import GHC.Utils.Outputable (Outputable(..), SDoc, (<+>), ($+$), vcat, empty, text) +#else +import Outputable (Outputable(..), SDoc, (<+>), ($+$), vcat, empty, text) +#endif +#if MIN_VERSION_ghc(8,10,0) +import GHC.Hs (hsmodName) +#else +import HsSyn (hsmodName) +#endif +import GHC (ModuleName) +#if MIN_VERSION_ghc(9,0,0) +import GHC.Types.SrcLoc (unLoc) +#else +import SrcLoc (unLoc) +#endif + +-- | A declaration, along with an optional comment. +-- +-- GHC's pretty-printer omits the contents of comments, so we can't use it here. +data CommentedDecl = CommentedDecl (Maybe SDoc) HsDecl' + +instance Outputable CommentedDecl where + ppr (CommentedDecl maybeComment decl) = + maybe empty pprComment maybeComment + $+$ ppr decl + where + pprComment c = text "{- |" <+> c <+> text "-}" + +uncommented :: HsDecl' -> CommentedDecl +uncommented = CommentedDecl Nothing + +commented :: SDoc -> HsDecl' -> CommentedDecl +commented = CommentedDecl . Just + +data CommentedModule = CommentedModule + { pragmaComments :: [String] + , moduleHeader :: HsModule' + , commentedDecls :: [CommentedDecl] + } + +getModuleName :: CommentedModule -> ModuleName +getModuleName m = + maybe + (error "getModuleName: No explicit name") + unLoc + (hsmodName $ moduleHeader m) + +instance Outputable CommentedModule where + ppr m = + vcat (map text $ pragmaComments m) + $+$ ppr (moduleHeader m) + $+$ vcat (map ppr $ commentedDecls m) + +languagePragma, optionsGhcPragma :: String -> String +languagePragma s = "{-# LANGUAGE " ++ s ++ "#-}" +optionsGhcPragma s = "{-# OPTIONS_GHC " ++ s ++ "#-}" diff --git a/app/Data/ProtoLens/Compiler/Generate/Encoding.hs b/app/Data/ProtoLens/Compiler/Generate/Encoding.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Generate/Encoding.hs @@ -0,0 +1,661 @@ +-- | This module generates code for decoding and encoding protocol buffer messages. +-- +-- Upstream docs: +{-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE NoMonomorphismRestriction #-} +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} +module Data.ProtoLens.Compiler.Generate.Encoding + ( generatedParser + , generatedBuilder + ) where + +import Data.Int (Int32) +import qualified Data.Map as Map +#if !MIN_VERSION_base(4,11,0) +import Data.Semigroup ((<>)) +#endif +import qualified Data.Text as Text +import Lens.Family2 ((^.)) +import GHC.SourceGen + +import Data.ProtoLens.Compiler.Definitions +import Data.ProtoLens.Compiler.Generate.Field +import Data.ProtoLens.Encoding.Wire (joinTypeAndTag) +import Proto.Google.Protobuf.Descriptor + ( FieldDescriptorProto'Type(..) + , FeatureSet'MessageEncoding(..) + ) + +generatedParser :: Env RdrNameStr -> MessageInfo OccNameStr -> HsExpr' +generatedParser env m = + {- let loop :: T -> Bool -> Bool -> ... + -> MVector RealWorld Int32 -> MVector RealWorld Float -> ... + -> Parser T + loop x required'a required'b ... mutable'a mutable'b ... = ... + in "package.T" do + mutable'a <- unsafeLiftIO new + mutable'b <- unsafeLiftIO new + ... + loop defMessage True True ... mutable'a mutable'b ... + -} + let' [typeSig loop loopSig + , funBind loop $ match (bvar <$> loopArgs names) loopExpr + ] + $ var "Data.ProtoLens.Encoding.Bytes." + @@ do' (startStmts ++ [stmt $ continue startExp]) + @@ string msgName + where + ty = var (unqual $ messageName m) + msgName = Text.unpack (messageDescriptor m ^. #name) + loopSig = foldr (-->) + (var "Data.ProtoLens.Encoding.Bytes.Parser" @@ ty) + (loopArgs $ parseStateTypes env m) + + names = parseStateNames m + exprs = fmap (var . unqual) names + tag = bvar "tag" + end = bvar "end" + loop = "loop" + + (startStmts, startExp) = startParse names + + continue :: ParseState HsExpr' -> HsExpr' + continue s = foldl (@@) (var loop) (loopArgs s) + + loopExpr + {- Group: + do + tag <- getVarInt + case tag of + {groupEndTag} -> {finish} + ... -- Regular message fields + + TODO(#282): fail the parse if we find a group-end tag + with an incorrect field number. + -} + | Just g <- groupFieldNumber m = do' + [ tag <-- getVarInt' + , stmt $ case' tag $ + match [int (groupEndTag g)] (finish m exprs) + : parseTagCases continue exprs m + ] + {- Regular message type: + do + end <- atEnd + if end + then {finish} + else do + tag <- getVarInt + case tag of ... + -} + | otherwise = do' + [ end <-- var "Data.ProtoLens.Encoding.Bytes.atEnd" + , stmt $ + if' end (finish m exprs) + $ do' + [ tag <-- getVarInt' + , stmt $ case' tag $ parseTagCases continue exprs m + ] + ] + +-- | A Parser expression that finalizes the message. +finish :: MessageInfo OccNameStr -> ParseState HsExpr' -> HsExpr' +finish m s = do' $ + {- do + frozen'a <- unsafeLiftIO $ unsafeFreeze mutable'a + frozen'b <- unsafeLiftIO $ unsafeFreeze mutable'b + ... + {checkMissingFields} + over unknownFields reverse + $ set field @"vec'a" frozen'a + $ set field @"vec'b" frozen'b + ... + $ {partialMessage} + -} + [ bvar frozen <-- unsafeLiftIO' @@ + (var "Data.ProtoLens.Encoding.Growing.unsafeFreeze" + @@ mutable) + | (frozen, mutable) <- Map.elems $ Map.intersectionWith (,) + frozenNames (repeatedFieldMVectors s) + ] + ++ + [ stmt $ checkMissingFields s + , stmt $ var "Prelude.return" @@ + (over' unknownFields' (var "Prelude.reverse") + @@ foldr (@@) + (partialMessage s) + (Map.intersectionWith + (\finfo frozen -> + var "Lens.Family2.set" + @@ fieldOfVector finfo + @@ var (unqual frozen)) + repeatedInfos frozenNames)) + ] + + where + repeatedInfos = repeatedFields m + frozenNames = (\f -> nameFromSymbol $ "frozen'" <> overloadedFieldName f) + <$> repeatedInfos + +-- | The state of the parsing loop. Each instance of @v@ corresponds +-- to an argument of the loop function. +data ParseState v = ParseState + { partialMessage :: v + -- ^ The message that we're parsing. + , requiredFieldsUnset :: Map.Map FieldId v + -- ^ The required fields of the message, each corresponding to + -- a @Bool@ argument of the loop. + , repeatedFieldMVectors :: Map.Map FieldId v + -- ^ The repeated fields of the message, each corresponding to + -- an @MVector@ argument of the loop. + } deriving Functor + +-- | Returns a sequence of all arguments of the loop function. +loopArgs :: ParseState v -> [v] +loopArgs s = partialMessage s : Map.elems (requiredFieldsUnset s) + ++ Map.elems (repeatedFieldMVectors s) + +-- | The proto name of the field. +newtype FieldId = FieldId Text.Text + deriving (Eq, Ord) + +fieldId :: PlainFieldInfo -> FieldId +fieldId f = FieldId $ fieldDescriptor (plainFieldInfo f) ^. #name + +-- | The names of the loop arguments. +parseStateNames :: MessageInfo OccNameStr -> ParseState OccNameStr +parseStateNames m = ParseState + { partialMessage = "x" + , requiredFieldsUnset = Map.fromList + [ (fieldId f, nameFromSymbol $ "required'" <> n) + | f <- messageFields m + , let info = plainFieldInfo f + , let n = overloadedFieldName info + , RequiredField <- [plainFieldKind f] + ] + , repeatedFieldMVectors = + (\f -> nameFromSymbol $ "mutable'" <> overloadedFieldName f) + <$> repeatedFields m + } + +repeatedFields :: MessageInfo OccNameStr -> Map.Map FieldId FieldInfo +repeatedFields m = Map.fromList + [ (fieldId f, plainFieldInfo f) + | f <- messageFields m + , RepeatedField{} <- [plainFieldKind f] + ] + +-- | Intialize the values of the loop arguments. +startParse :: ParseState OccNameStr -> ([Stmt'], ParseState HsExpr') +startParse names = + ([ bvar n <-- unsafeLiftIO' @@ var "Data.ProtoLens.Encoding.Growing.new" + | n <- Map.elems mvectorNames + ] + , ParseState + { partialMessage = var "Data.ProtoLens.defMessage" + , requiredFieldsUnset = const (var "Prelude.True") + <$> requiredFieldsUnset names + , repeatedFieldMVectors = var . unqual <$> mvectorNames + } + ) + where + mvectorNames = repeatedFieldMVectors names + +-- | The types of the loop arguments. +parseStateTypes :: Env RdrNameStr -> MessageInfo OccNameStr -> ParseState HsType' +parseStateTypes env m = ParseState + { partialMessage = var $ unqual $ messageName m + , requiredFieldsUnset = fmap (const $ var "Prelude.Bool") + $ requiredFieldsUnset + $ parseStateNames m + , repeatedFieldMVectors = growingType env <$> repeatedFields m + } + +-- | Transform the loop arguments by applying a given function +-- to the intermediate message value. +updateParseState :: + HsExpr' -- ^ An expression of type @msg -> msg@ + -> ParseState HsExpr' + -> ParseState HsExpr' +updateParseState f s = s { partialMessage = f @@ partialMessage s } + +-- | Transform the loop arguments by marking a required field +-- as having been set. +markRequiredField :: FieldId -> ParseState HsExpr' -> ParseState HsExpr' +markRequiredField f s = + s { requiredFieldsUnset = Map.insert f (var "Prelude.False") + $ requiredFieldsUnset s } + +-- | Append to the given repeated field. +appendToRepeated :: FieldId -> HsExpr' -> ParseState HsExpr' -> (Stmt', ParseState HsExpr') +appendToRepeated f x s = + ( v <-- unsafeLiftIO' + @@ (var "Data.ProtoLens.Encoding.Growing.append" + @@ (repeatedFieldMVectors s Map.! f) + @@ x) + , s { repeatedFieldMVectors = + Map.insert f v + $ repeatedFieldMVectors s + } + ) + where + v = bvar "v" + +-- | Returns an HsExpr' of type @Parser ()@ +-- which fails if any of the missing fields aren't set. +checkMissingFields :: ParseState HsExpr' -> HsExpr' +checkMissingFields s = + {- let missing = (if required'a then ("a":) else id) + ((if required'b then ("b":) else id) + ... []) + in if null missing then return () + else fail ("Missing required fields: " ++ show missing) + -} + let' [valBind missing allMissingFields] + $ if' (var "Prelude.null" @@ var missing) (var "Prelude.return" @@ unit) + $ var "Prelude.fail" + @@ (var "Prelude.++" + @@ string "Missing required fields: " + @@ (var "Prelude.show" @@ (var missing @::@ listTy (var "Prelude.String")))) + where + missing = "missing" + allMissingFields = Map.foldrWithKey consIfMissing (list []) (requiredFieldsUnset s) + consIfMissing (FieldId f) e rest = + if' e (cons @@ string (Text.unpack f)) (var "Prelude.id") @@ rest + +-- | A list case alternatives for the fields of a message. +-- +-- The exact structure of each case differs based on the field type. However, it +-- generally looks like: +-- +-- @ +-- {N} -> do +-- {VALUE} <- {PARSE} +-- loop (set {FIELD} {VALUE} x) required'a False required'c ... +-- @ +-- +-- where: +-- - {N} is an integer representing the wire type + field number, +-- - {VALUE} is an expression of type "V", which is the type of the field, +-- - {PARSE} is an expression of the form "Parser V", +-- - and "loop" and "x" are as in @generatedParser@. +parseTagCases :: + (ParseState HsExpr' -> HsExpr') + -- ^ loop continuation, equivalent to "msg -> Bool -> ... -> Bool -> Parser msg". + -- It continues the loop with the given new value of the message, keeping track + -- of whether the required fields are still needed. + -> ParseState HsExpr' -- ^ Previous value of the message and required field states + -> MessageInfo OccNameStr + -> [RawMatch] +parseTagCases loop x info = + concatMap (parseFieldCase loop x) allFields + -- TODO: currently we ignore unknown fields. + ++ [unknownFieldCase info loop x] + where + allFields = messageFields info + -- Cases of a oneof are decoded like optional oneof fields. + ++ [ PlainFieldInfo OptionalMaybeField (caseField c) + | o <- messageOneofFields info + , c <- oneofCases o + ] + +-- | A particular parsing case. See @parseTagCases@ for details. +parseFieldCase :: + (ParseState HsExpr' -> HsExpr') -> ParseState HsExpr' -> PlainFieldInfo -> [RawMatch] +parseFieldCase loop x f = case plainFieldKind f of + MapField entryInfo -> [mapCase entryInfo] + RepeatedField p + | p == NotPackable -> [unpackedCase] + | otherwise -> [unpackedCase, packedCase] + RequiredField -> [requiredCase] + _ -> [valueCase] + where + y = bvar "y" + entry = bvar "entry" + info = plainFieldInfo f + valueCase = match [int (fieldTag info)] $ do' + [ y <-- parseField info + , stmt . loop . updateParseState (setField info @@ y) + $ x + ] + requiredCase = match [int (fieldTag info)] $ do' + [ y <-- parseField info + , stmt . loop + . updateParseState (setField info @@ y) + . markRequiredField (fieldId f) + $ x + ] + unpackedCase = match [int (fieldTag info)] + $ let (appendStmt, x') = appendToRepeated (fieldId f) y x + in do' + [ strictP y <-- parseField info + , appendStmt + , stmt . loop $ x' + ] + packedCase = match [int (packedFieldTag info)] $ do' + [ y <-- isolatedLengthy (parsePackedField info + @@ repeatedFieldMVectors x Map.! fieldId f) + , stmt $ loop x { repeatedFieldMVectors = + Map.insert (fieldId f) y + $ repeatedFieldMVectors x } + ] + mapCase entryInfo = match [int (fieldTag info)] $ do' + [ strictP (entry `sigP` var (unqual $ mapEntryTypeName entryInfo)) + <-- parseField info + , stmt . let' [ valBind "key" + $ view' @@ fieldOf (keyField entryInfo) + @@ entry + , valBind "value" + $ view' @@ fieldOf (valueField entryInfo) + @@ entry + ] + . loop + . updateParseState + (overField info + (var "Data.Map.insert" @@ var "key" @@ var "value")) + $ x + ] + +unknownFieldCase :: + MessageInfo OccNameStr -> (ParseState HsExpr' -> HsExpr') -> ParseState HsExpr' -> RawMatch +{- + wire -> do + !y <- parseTaggedValueFromWire wire + -- Omitted if not a group: + case y of + TaggedValue utag EndGroup + -> fail ("Mismatched group-end tag number " ++ show utag) + _ -> return () + loop (over unknownFields (\!t -> y:t) x) ... +-} +unknownFieldCase info loop x = match [wire] $ do' $ + [ strictP y <-- if messageDescriptor info ^. #options . #messageSetWireFormat + then var "Data.ProtoLens.Encoding.Wire.parseMessageSetTaggedValueFromWire" @@ wire + else var "Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire" @@ wire + ] + ++ + [ stmt $ case' y + [ match + [conP "Data.ProtoLens.Encoding.Wire.TaggedValue" + [utag, conP_ "Data.ProtoLens.Encoding.Wire.EndGroup"]] + $ var "Prelude.fail" @@ + (var "Prelude.++" + @@ string "Mismatched group-end tag number " + @@ (var "Prelude.show" @@ utag)) + , match [wildP] $ var "Prelude.return" @@ unit + ] + | Just _ <- [groupFieldNumber info] + ] + ++ + [ stmt . loop . updateParseState (over' unknownFields' (cons @@ y)) + $ x + ] + where + wire = bvar "wire" + y = bvar "y" + utag = bvar "utag" + +-- | An expression of type "b -> a -> a", corresponding to a Lens a b +-- for this field. +setField :: FieldInfo -> HsExpr' +setField f = var "Lens.Family2.set" @@ fieldOf f + +-- | An expression of type "(b -> b) -> a -> a", corresponding to a +-- Lens a b for this field. +overField :: FieldInfo -> HsExpr' -> HsExpr' +overField f = over' (fieldOf f) + +-- | An expression of type "(b -> b) -> a -> a". +-- +-- Specifically, this renders to: +-- over f (\!z -> g z) x +-- The extra strictness prevents a space leak due to lists being lazy. +over' :: HsExpr' -> HsExpr' -> HsExpr' +over' f g = var "Lens.Family2.over" + @@ f + @@ lambda [strictP t] (g @@ t) + where + t = bvar "t" + +-- | A "Growing v RealWorld a -> Parser (Growing v RealWorld a)" +-- for a field that can be packed. +parsePackedField :: FieldInfo -> HsExpr' +{- let ploop qs = do + packedEnd <- atEnd + if packedEnd + then return qs + else do + !q <- {PARSE FIELD} + qs' <- append qs q + ploop qs' + in ploop +-} +parsePackedField info = let' [funBind ploop $ match [qs] ploopExp] + (var ploop) + where + ploop = "ploop" + q = bvar "q" + qs = bvar "qs" + qs' = bvar "qs'" + packedEnd = bvar "packedEnd" + ploopExp = do' + [ packedEnd <-- var "Data.ProtoLens.Encoding.Bytes.atEnd" + , stmt $ + if' packedEnd + (var "Prelude.return" @@ qs) + $ do' + [ strictP q <-- parseField info + , qs' <-- unsafeLiftIO' @@ + (var "Data.ProtoLens.Encoding.Growing.append" + @@ qs @@ q) + , stmt $ var ploop @@ qs' + ] + ] + +generatedBuilder :: MessageInfo OccNameStr -> HsExpr' +generatedBuilder m = + lambda [x] $ foldMapExp $ map (buildPlainField x) (messageFields m) + ++ map (buildOneofField x) (messageOneofFields m) + ++ [if messageDescriptor m ^. #options . #messageSetWireFormat + then buildUnknownMessageSet x else buildUnknown x] + ++ buildGroupEnd + where + x = bvar "_x" -- TODO: rename to "x" once it's always used + -- If this is a group, finish by emitting the end-group tag. + buildGroupEnd = [ putVarInt' @@ int (groupEndTag g) + | Just g <- [groupFieldNumber m] + ] + +buildUnknown :: HsExpr' -> HsExpr' +buildUnknown x + = var "Data.ProtoLens.Encoding.Wire.buildFieldSet" + @@ (view' @@ unknownFields' @@ x) + +buildUnknownMessageSet :: HsExpr' -> HsExpr' +buildUnknownMessageSet x + = var "Data.ProtoLens.Encoding.Wire.buildMessageSet" + @@ (view' @@ unknownFields' @@ x) + +-- | Concatenate a list of Monoids into a single value. +-- For example, foldMapExp [a,b,c] will be transformed into +-- the (unrolled) expression a <> b <> c. +foldMapExp :: [HsExpr'] -> HsExpr' +foldMapExp [] = mempty' +foldMapExp [x] = x +foldMapExp (x:xs) = var "Data.Monoid.<>" @@ x @@ foldMapExp xs + +-- | An expression of type @Builder@ which encodes the field value +-- @x@ based on the kind and type of the field @f@. +buildPlainField :: HsExpr' -> PlainFieldInfo -> HsExpr' +buildPlainField x f = case plainFieldKind f of + RequiredField -> buildTaggedField info fieldValue + OptionalMaybeField -> case' maybeFieldValue + [ match [conP_ "Prelude.Nothing"] mempty' + , match [conP "Prelude.Just" [v']] + $ buildTaggedField info v' + ] + OptionalValueField -> let' [valBind v fieldValue] + $ if' (var "Prelude.==" @@ v' @@ var "Data.ProtoLens.fieldDefault") + mempty' + (buildTaggedField info v') + MapField entryInfo + -> var "Data.Monoid.mconcat" + @@ (var "Prelude.map" + @@ lambda [v'] (buildEntry entryInfo v') + @@ (var "Data.Map.toList" @@ fieldValue)) + RepeatedField Packed -> buildPackedField info vectorFieldValue + RepeatedField _ -> var "Data.ProtoLens.Encoding.Bytes.foldMapBuilder" + @@ lambda [v'] + (buildTaggedField info v') + @@ vectorFieldValue + where + info = plainFieldInfo f + v = "_v" + v' = bvar v + fieldValue = view' + @@ fieldOf info + @@ x + maybeFieldValue = view' + @@ fieldOfMaybe info + @@ x + vectorFieldValue = view' + @@ fieldOfVector info + @@ x + {- Builds a value of the given map entry type + from the given key/value pair kv. + + ... set (fieldOf {KEY}) (fst kv) + (set (fieldOf {VALUE}) (snd kv) + (defMessage :: Foo'Entry) + -} + buildEntry entry kv + = buildTaggedField info + $ set' + @@ fieldOf (keyField entry) + @@ (var "Prelude.fst" @@ kv) + @@ (set' @@ fieldOf (valueField entry) + @@ (var "Prelude.snd" @@ kv) + @@ (var "Data.ProtoLens.defMessage" + @::@ var (unqual $ mapEntryTypeName entry))) + +fieldOf :: FieldInfo -> HsExpr' +fieldOf = fieldOfExp . overloadedFieldName + +fieldOfMaybe :: FieldInfo -> HsExpr' +fieldOfMaybe = fieldOfExp . ("maybe'" <>) . overloadedFieldName + +fieldOfOneof :: OneofInfo -> HsExpr' +fieldOfOneof = + fieldOfExp . ("maybe'" <>) . overloadedName . oneofFieldName + +fieldOfVector :: FieldInfo -> HsExpr' +fieldOfVector = fieldOfExp . ("vec'" <>) . overloadedFieldName + +-- | Build a field along with its tag. +buildTaggedField :: FieldInfo -> HsExpr' -> HsExpr' +buildTaggedField f x = foldMapExp + [ putVarInt' @@ int (fieldTag f) + , buildField f @@ x + ] + +-- | Encodes a packed field as a byte string, along with +-- its wire type+number. +buildPackedField :: FieldInfo -> HsExpr' -> HsExpr' +{- + let p = x -- where x might be a complicated expression + in if null p then mempty + else putVarInt {TAG} + <> ... (runBuilder (mconcat (map {BUILD_ELT} p))) +-} +buildPackedField f x = let' [valBind p x] + $ if' (var "Data.Vector.Generic.null" @@ var p) mempty' + $ var "Data.Monoid.<>" + @@ (putVarInt' @@ int (packedFieldTag f)) + @@ (buildFieldType lengthy + @@ (var "Data.ProtoLens.Encoding.Bytes.runBuilder" + @@ (var "Data.ProtoLens.Encoding.Bytes.foldMapBuilder" + @@ buildField f + @@ var p))) + where + p = "p" + +buildOneofField :: HsExpr' -> OneofInfo -> HsExpr' +buildOneofField x info = case' (view' @@ fieldOfOneof info @@ x) $ + match [conP_ "Prelude.Nothing"] mempty' + : [ match [conP "Prelude.Just" [conP (unqual $ caseConstructorName c) + [v]]] + $ buildTaggedField (caseField c) v + | c <- oneofCases info + ] + where + v = bvar "v" + +-- | Compute the proto encoding's representation of the wire type +-- and field number. +-- +-- The last three bits of the number store the wire type, and the +-- rest store the field number as a varint. +makeTag :: Int32 -> FieldEncoding -> Integer +makeTag num enc = fromIntegral $ joinTypeAndTag (fromIntegral num) (wireType enc) + +fieldTag :: FieldInfo -> Integer +fieldTag f = makeTag (fieldDescriptor f ^. #number) $ fieldInfoEncoding f + +packedFieldTag :: FieldInfo -> Integer +packedFieldTag f = makeTag (fieldDescriptor f ^. #number) lengthy + +groupEndTag :: Int32 -> Integer +groupEndTag num = makeTag num groupEnd + +-- | An expression that selects the overloaded field lens of this name. +-- +-- field @"fieldName" +fieldOfExp :: Symbol -> HsExpr' +fieldOfExp sym = tyApp (var "Data.ProtoLens.Field.field") (promoteSymbol sym) + +-- | Some functions that are used in multiple places in the generated code. +getVarInt', putVarInt', mempty', view', set', unknownFields', unsafeLiftIO' + :: HsExpr' +getVarInt' = var "Data.ProtoLens.Encoding.Bytes.getVarInt" +putVarInt' = var "Data.ProtoLens.Encoding.Bytes.putVarInt" +mempty' = var "Data.Monoid.mempty" +view' = var "Lens.Family2.view" +set' = var "Lens.Family2.set" +unknownFields' = var "Data.ProtoLens.unknownFields" +unsafeLiftIO' = var "Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO" + +-- | Returns an expression of type @Parser a@ for the given field. +parseField :: FieldInfo -> HsExpr' +parseField f = var "Data.ProtoLens.Encoding.Bytes." + @@ parseFieldType (fieldInfoEncoding f) + @@ string n + where + n = Text.unpack (fieldDescriptor f ^. #name) + +-- | Returns a function corresponding to `a -> Builder`: +buildField :: FieldInfo -> HsExpr' +buildField = buildFieldType . fieldInfoEncoding + +fieldInfoEncoding :: FieldInfo -> FieldEncoding +fieldInfoEncoding info + -- In almost all cases, the encoding of a type is determined only by the type. + -- There is one exception introduced in Protobuf Editions, and this is the + -- ability to control the message encoding with "features.message_encoding". + | isMessage = messageEncoding + | otherwise = fieldEncoding $ fieldDescriptor info ^. #type' + where + descriptor = fieldDescriptor info + isMessage = descriptor ^. #type' == FieldDescriptorProto'TYPE_MESSAGE + messageEncoding = case descriptor ^. #options . #features . #messageEncoding of + -- DELIMITED encoding is the same as proto2 group encoding. + FeatureSet'DELIMITED -> fieldEncoding FieldDescriptorProto'TYPE_GROUP + _ -> fieldEncoding FieldDescriptorProto'TYPE_MESSAGE + +growingType :: Env RdrNameStr -> FieldInfo -> HsType' +growingType env f + = var "Data.ProtoLens.Encoding.Growing.Growing" + @@ hsFieldVectorType f + @@ var "Data.ProtoLens.Encoding.Growing.RealWorld" + @@ hsFieldType env f diff --git a/app/Data/ProtoLens/Compiler/Generate/Field.hs b/app/Data/ProtoLens/Compiler/Generate/Field.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Generate/Field.hs @@ -0,0 +1,242 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoMonomorphismRestriction #-} +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} +-- | This module generates the code for decoding and encoding +-- individual field types. +-- +-- Upstream docs: +-- +module Data.ProtoLens.Compiler.Generate.Field + ( hsFieldType + , hsFieldVectorType + , FieldEncoding(..) + , fieldEncoding + , lengthy + , groupEnd + , isolatedLengthy + ) where + +import Data.Text (unpack) +import Data.Word (Word8) +import Lens.Family2 +import Proto.Google.Protobuf.Descriptor (FieldDescriptorProto'Type(..)) + +import Data.ProtoLens.Compiler.Definitions + +import GHC.SourceGen + +hsFieldType :: Env RdrNameStr -> FieldInfo -> HsType' +hsFieldType env f = let + fd = fieldDescriptor f + in var $ case fd ^. #type' of + FieldDescriptorProto'TYPE_DOUBLE -> "Prelude.Double" + FieldDescriptorProto'TYPE_FLOAT -> "Prelude.Float" + FieldDescriptorProto'TYPE_INT64 -> "Data.Int.Int64" + FieldDescriptorProto'TYPE_UINT64 -> "Data.Word.Word64" + FieldDescriptorProto'TYPE_INT32 -> "Data.Int.Int32" + FieldDescriptorProto'TYPE_FIXED64 -> "Data.Word.Word64" + FieldDescriptorProto'TYPE_FIXED32 -> "Data.Word.Word32" + FieldDescriptorProto'TYPE_BOOL -> "Prelude.Bool" + FieldDescriptorProto'TYPE_STRING -> "Data.Text.Text" + FieldDescriptorProto'TYPE_GROUP + | Message m <- definedFieldType fd env -> messageName m + | otherwise -> error $ "expected TYPE_GROUP for type name" + ++ unpack (fd ^. #typeName) + FieldDescriptorProto'TYPE_MESSAGE + | Message m <- definedFieldType fd env -> messageName m + | otherwise -> error $ "expected TYPE_MESSAGE for type name" + ++ unpack (fd ^. #typeName) + FieldDescriptorProto'TYPE_BYTES -> "Data.ByteString.ByteString" + FieldDescriptorProto'TYPE_UINT32 -> "Data.Word.Word32" + FieldDescriptorProto'TYPE_ENUM + | Enum e <- definedFieldType fd env -> enumName e + | otherwise -> error $ "expected TYPE_ENUM for type name" + ++ unpack (fd ^. #typeName) + FieldDescriptorProto'TYPE_SFIXED32 -> "Data.Int.Int32" + FieldDescriptorProto'TYPE_SFIXED64 -> "Data.Int.Int64" + FieldDescriptorProto'TYPE_SINT32 -> "Data.Int.Int32" + FieldDescriptorProto'TYPE_SINT64 -> "Data.Int.Int64" + +hsFieldVectorType :: FieldInfo -> HsType' +hsFieldVectorType f = case fieldDescriptor f ^. #type' of + FieldDescriptorProto'TYPE_MESSAGE -> boxed + -- TODO: store enums in unboxed fields. + FieldDescriptorProto'TYPE_ENUM -> boxed + FieldDescriptorProto'TYPE_GROUP -> boxed + FieldDescriptorProto'TYPE_STRING -> boxed + FieldDescriptorProto'TYPE_BYTES -> boxed + _ -> unboxed + where + boxed = var "Data.Vector.Vector" + unboxed = var "Data.Vector.Unboxed.Vector" + +-- | A representation for how to encode and decode a particular field type. +data FieldEncoding = FieldEncoding + { buildFieldType :: HsExpr' -- ^ :: a -> Builder + , parseFieldType :: HsExpr' -- ^ :: Parser a + , wireType :: Word8 + } + +-- | A variable-length integer, decoded as an unsigned Word64. +varint :: FieldEncoding +varint = FieldEncoding + { wireType = 0 + , buildFieldType = putVarInt' + , parseFieldType = getVarInt' + } + +-- | A fixed-length integer (Word64). +fixed64 :: FieldEncoding +fixed64 = FieldEncoding + { wireType = 1 + , buildFieldType = var "Data.ProtoLens.Encoding.Bytes.putFixed64" + , parseFieldType = var "Data.ProtoLens.Encoding.Bytes.getFixed64" + } + +-- | A fixed-length integer (Word32). +fixed32 :: FieldEncoding +fixed32 = FieldEncoding + { wireType = 5 + , buildFieldType = var "Data.ProtoLens.Encoding.Bytes.putFixed32" + , parseFieldType = var "Data.ProtoLens.Encoding.Bytes.getFixed32" + } + +-- | A ByteString, prefixed by its length (which is encoded as a varint). +lengthy :: FieldEncoding +lengthy = FieldEncoding + { wireType = 2 + , buildFieldType = buildLengthy + , parseFieldType = parseLengthy + } + where + bs = bvar "bs" + len = bvar "len" + buildLengthy = + -- Bind x since it may be a nontrivial expression: + lambda [bs] + $ var "Data.Monoid.<>" + @@ (putVarInt' + @@ (fromIntegral' + @@ (var "Data.ByteString.length" @@ bs))) + @@ (var "Data.ProtoLens.Encoding.Bytes.putBytes" @@ bs) + parseLengthy = do' + [ len <-- getVarInt' + , stmt $ var "Data.ProtoLens.Encoding.Bytes.getBytes" + @@ (fromIntegral' @@ len) + ] + +group :: FieldEncoding +group = FieldEncoding + { wireType = 3 + , buildFieldType = var "Data.ProtoLens.buildMessage" + , parseFieldType = var "Data.ProtoLens.parseMessage" + } + +groupEnd :: FieldEncoding +groupEnd = FieldEncoding + { wireType = 4 + , buildFieldType = var "Prelude.const" @@ var "Data.Monoid.mempty" + , parseFieldType = var "Prelude.return" @@ unit + } + +-- Wrap a field encoding with Haskell functions that should always succeed. +bijectField :: HsExpr' -> HsExpr' -> FieldEncoding -> FieldEncoding +bijectField buildF parseF f = FieldEncoding + { buildFieldType = var "Prelude.." @@ buildFieldType f @@ buildF + , parseFieldType = var "Prelude.fmap" @@ parseF @@ parseFieldType f + , wireType = wireType f + } + +-- | Convert a field of one integral type to another. +integralField :: FieldEncoding -> FieldEncoding +integralField = bijectField fromIntegral' fromIntegral' + +fieldEncoding :: FieldDescriptorProto'Type -> FieldEncoding +fieldEncoding = \case + FieldDescriptorProto'TYPE_INT64 -> integralField varint + FieldDescriptorProto'TYPE_UINT64 -> varint + FieldDescriptorProto'TYPE_INT32 -> integralField varint + FieldDescriptorProto'TYPE_UINT32 -> integralField varint + FieldDescriptorProto'TYPE_FIXED64 -> fixed64 + FieldDescriptorProto'TYPE_FIXED32 -> fixed32 + FieldDescriptorProto'TYPE_SFIXED64 -> integralField fixed64 + FieldDescriptorProto'TYPE_SFIXED32 -> integralField fixed32 + FieldDescriptorProto'TYPE_DOUBLE -> + bijectField + (var "Data.ProtoLens.Encoding.Bytes.doubleToWord") + (var "Data.ProtoLens.Encoding.Bytes.wordToDouble") + fixed64 + FieldDescriptorProto'TYPE_FLOAT -> + bijectField + (var "Data.ProtoLens.Encoding.Bytes.floatToWord") + (var "Data.ProtoLens.Encoding.Bytes.wordToFloat") + fixed32 + FieldDescriptorProto'TYPE_BOOL -> + bijectField + (lambda [bvar "b"] $ if' (var "b") (int 1) (int 0)) + (var "Prelude./=" @@ int 0) + varint + FieldDescriptorProto'TYPE_ENUM -> + -- TODO: don't throw an exception on unknown proto2 enums. + bijectField (var "Prelude.fromEnum") (var "Prelude.toEnum") + $ integralField varint + FieldDescriptorProto'TYPE_SINT64 -> + bijectField + (var "Data.ProtoLens.Encoding.Bytes.signedInt64ToWord") + (var "Data.ProtoLens.Encoding.Bytes.wordToSignedInt64") + $ integralField varint + FieldDescriptorProto'TYPE_SINT32 -> + bijectField + (var "Data.ProtoLens.Encoding.Bytes.signedInt32ToWord") + (var "Data.ProtoLens.Encoding.Bytes.wordToSignedInt32") + $ integralField varint + FieldDescriptorProto'TYPE_BYTES -> lengthy + FieldDescriptorProto'TYPE_STRING -> stringField + FieldDescriptorProto'TYPE_MESSAGE -> message + FieldDescriptorProto'TYPE_GROUP -> group + +-- | A string, represented as Data.Text.Text. +stringField :: FieldEncoding +stringField = + FieldEncoding + { wireType = 2 + , buildFieldType = buildString + , parseFieldType = parseString + } + where + len = bvar "len" + buildString = var "Prelude.." @@ buildFieldType lengthy + @@ var "Data.Text.Encoding.encodeUtf8" + parseString = do' + [ len <-- getVarInt' + , stmt $ var "Data.ProtoLens.Encoding.Bytes.getText" + @@ (fromIntegral' @@ len) + ] + +-- | A protobuf message type. +message :: FieldEncoding +message = lengthy + { buildFieldType = var "Prelude.." @@ + buildFieldType lengthy @@ + var "Data.ProtoLens.encodeMessage" + , parseFieldType = isolatedLengthy (var "Data.ProtoLens.parseMessage") + } + +-- | Takes a @Parser a@, reads a varint and then runs the parser +-- isolated to the given length. +isolatedLengthy :: HsExpr' -> HsExpr' +isolatedLengthy parser = do' + [ len <-- getVarInt' + , stmt $ var "Data.ProtoLens.Encoding.Bytes.isolate" + @@ (fromIntegral' @@ len) + @@ parser + ] + where + len = bvar "len" + +-- | Some functions that are used in multiple places in the generated code. +getVarInt', putVarInt', fromIntegral' :: HsExpr' +getVarInt' = var "Data.ProtoLens.Encoding.Bytes.getVarInt" +putVarInt' = var "Data.ProtoLens.Encoding.Bytes.putVarInt" +fromIntegral' = var "Prelude.fromIntegral" diff --git a/app/Data/ProtoLens/Compiler/Plugin.hs b/app/Data/ProtoLens/Compiler/Plugin.hs new file mode 100644 --- /dev/null +++ b/app/Data/ProtoLens/Compiler/Plugin.hs @@ -0,0 +1,105 @@ +-- Copyright 2016 Google Inc. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd +-- +-- Code for writing protocol compiler plugins. + +{-# LANGUAGE CPP #-} +{-# LANGUAGE OverloadedLabels #-} +module Data.ProtoLens.Compiler.Plugin + ( ProtoFileName + , ProtoFile(..) + , analyzeProtoFiles + , collectEnvFromDeps + ) where + +import qualified Data.Foldable as F +import qualified Data.Map.Strict as Map +import Data.Map.Strict (Map, unions, (!)) +import Data.String (fromString) +import qualified Data.Text as T +import Data.Text (Text) +import Lens.Family2 +import Proto.Google.Protobuf.Descriptor (FileDescriptorProto) + +import Data.ProtoLens.Compiler.Definitions +import Data.ProtoLens.Compiler.ModuleName + +import GHC.SourceGen (ModuleNameStr, OccNameStr, RdrNameStr) + +-- | The filename of an input .proto file. +type ProtoFileName = Text + +data ProtoFile = ProtoFile + { descriptor :: FileDescriptorProto + , haskellModule :: ModuleNameStr + , definitions :: Env OccNameStr + , services :: [ServiceInfo] + , exportedEnv :: Env RdrNameStr + , publicImports :: [ModuleNameStr] + } + +-- Given a list of FileDescriptorProtos, collect information about each file +-- into a map of 'ProtoFile's keyed by 'ProtoFileName'. +analyzeProtoFiles :: [FileDescriptorProto] -> Either Text (Map ProtoFileName ProtoFile) +analyzeProtoFiles files = do + -- The definitions in each input proto file, indexed by filename. + definitionsByName <- mapM collectDefinitions filesByName + let servicesByName = fmap collectServices filesByName + let exportsByName = transitiveExports files + let exportedEnvs = fmap (foldMap (definitionsByName !)) exportsByName + + let ingestFile f = ProtoFile + { descriptor = f + , haskellModule = m + , definitions = definitionsByName ! n + , services = servicesByName ! n + , exportedEnv = qualifyEnv m $ exportedEnvs ! n + , publicImports = [moduleNames ! i | i <- reexported] + } + where + n = f ^. #name + m = moduleNames ! n + reexported = + [ (f ^. #dependency) !! fromIntegral i + | i <- f ^. #publicDependency + ] + + return $ Map.fromList [ (f ^. #name, ingestFile f) | f <- files ] + where + filesByName = Map.fromList [(f ^. #name, f) | f <- files] + moduleNames = fmap fdModuleName filesByName + +collectEnvFromDeps :: [ProtoFileName] -> Map ProtoFileName ProtoFile -> Env RdrNameStr +collectEnvFromDeps deps filesByName = + unions $ fmap (exportedEnv . (filesByName !)) deps + +-- | Get the Haskell 'ModuleName' corresponding to a given .proto file. +fdModuleName :: FileDescriptorProto -> ModuleNameStr +fdModuleName fd + = fromString $ protoModuleName (T.unpack $ fd ^. #name) + +-- | Given a list of .proto files (topologically sorted), determine which +-- files' definitions are exported by which files. +-- +-- Files only export their own definitions, along with the definitions exported +-- by any "import public" declarations. (And any definitions that *those* files +-- "import public", etc.) +transitiveExports :: [FileDescriptorProto] -> Map ProtoFileName [ProtoFileName] +-- Accumulate the transitive dependencies by folding over the files in +-- topological order. +transitiveExports = F.foldl' setExportsFromFile Map.empty + where + setExportsFromFile :: Map ProtoFileName [ProtoFileName] + -> FileDescriptorProto + -> Map ProtoFileName [ProtoFileName] + setExportsFromFile prevExports fd + = flip (Map.insert n) prevExports $ + n : concat [ prevExports ! ((fd ^. #dependency) !! fromIntegral i) + -- Note that publicDependency is a list of indices into + -- the dependency list. + | i <- fd ^. #publicDependency + ] + where n = fd ^. #name diff --git a/app/Proto/Google/Protobuf/Compiler/Plugin.hs b/app/Proto/Google/Protobuf/Compiler/Plugin.hs new file mode 100644 --- /dev/null +++ b/app/Proto/Google/Protobuf/Compiler/Plugin.hs @@ -0,0 +1,1811 @@ +{- 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, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-} +{-# OPTIONS_GHC -Wno-unused-imports#-} +{-# OPTIONS_GHC -Wno-duplicate-exports#-} +{-# OPTIONS_GHC -Wno-dodgy-exports#-} +module Proto.Google.Protobuf.Compiler.Plugin ( + CodeGeneratorRequest(), CodeGeneratorResponse(), + CodeGeneratorResponse'Feature(..), CodeGeneratorResponse'Feature(), + CodeGeneratorResponse'File(), Version() + ) where +import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism +import qualified Data.ProtoLens.Runtime.Prelude as Prelude +import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int +import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid +import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word +import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types +import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2 +import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text +import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map +import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString +import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8 +import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding +import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector +import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic +import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed +import qualified Data.ProtoLens.Runtime.Text.Read as 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.vec'fileToGenerate' @:: Lens' CodeGeneratorRequest (Data.Vector.Vector 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]@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'protoFile' @:: Lens' CodeGeneratorRequest (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.sourceFileDescriptors' @:: Lens' CodeGeneratorRequest [Proto.Google.Protobuf.Descriptor.FileDescriptorProto]@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'sourceFileDescriptors' @:: Lens' CodeGeneratorRequest (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.compilerVersion' @:: Lens' CodeGeneratorRequest Version@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'compilerVersion' @:: Lens' CodeGeneratorRequest (Prelude.Maybe Version)@ -} +data CodeGeneratorRequest + = CodeGeneratorRequest'_constructor {_CodeGeneratorRequest'fileToGenerate :: !(Data.Vector.Vector Data.Text.Text), + _CodeGeneratorRequest'parameter :: !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorRequest'protoFile :: !(Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto), + _CodeGeneratorRequest'sourceFileDescriptors :: !(Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto), + _CodeGeneratorRequest'compilerVersion :: !(Prelude.Maybe Version), + _CodeGeneratorRequest'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show CodeGeneratorRequest where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "fileToGenerate" [Data.Text.Text] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'fileToGenerate + (\ x__ y__ -> x__ {_CodeGeneratorRequest'fileToGenerate = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "vec'fileToGenerate" (Data.Vector.Vector Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'fileToGenerate + (\ x__ y__ -> x__ {_CodeGeneratorRequest'fileToGenerate = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "parameter" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'parameter + (\ x__ y__ -> x__ {_CodeGeneratorRequest'parameter = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "maybe'parameter" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'parameter + (\ x__ y__ -> x__ {_CodeGeneratorRequest'parameter = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "protoFile" [Proto.Google.Protobuf.Descriptor.FileDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'protoFile + (\ x__ y__ -> x__ {_CodeGeneratorRequest'protoFile = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "vec'protoFile" (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'protoFile + (\ x__ y__ -> x__ {_CodeGeneratorRequest'protoFile = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "sourceFileDescriptors" [Proto.Google.Protobuf.Descriptor.FileDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'sourceFileDescriptors + (\ x__ y__ + -> x__ {_CodeGeneratorRequest'sourceFileDescriptors = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "vec'sourceFileDescriptors" (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'sourceFileDescriptors + (\ x__ y__ + -> x__ {_CodeGeneratorRequest'sourceFileDescriptors = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "compilerVersion" Version where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'compilerVersion + (\ x__ y__ -> x__ {_CodeGeneratorRequest'compilerVersion = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "maybe'compilerVersion" (Prelude.Maybe Version) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'compilerVersion + (\ x__ y__ -> x__ {_CodeGeneratorRequest'compilerVersion = y__})) + Prelude.id +instance Data.ProtoLens.Message CodeGeneratorRequest where + messageName _ + = Data.Text.pack "google.protobuf.compiler.CodeGeneratorRequest" + packedMessageDescriptor _ + = "\n\ + \\DC4CodeGeneratorRequest\DC2(\n\ + \\DLEfile_to_generate\CAN\SOH \ETX(\tR\SOfileToGenerate\DC2\FS\n\ + \\tparameter\CAN\STX \SOH(\tR\tparameter\DC2C\n\ + \\n\ + \proto_file\CAN\SI \ETX(\v2$.google.protobuf.FileDescriptorProtoR\tprotoFile\DC2\\\n\ + \\ETBsource_file_descriptors\CAN\DC1 \ETX(\v2$.google.protobuf.FileDescriptorProtoR\NAKsourceFileDescriptors\DC2L\n\ + \\DLEcompiler_version\CAN\ETX \SOH(\v2!.google.protobuf.compiler.VersionR\SIcompilerVersion" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"protoFile")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorRequest + sourceFileDescriptors__field_descriptor + = Data.ProtoLens.FieldDescriptor + "source_file_descriptors" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor Proto.Google.Protobuf.Descriptor.FileDescriptorProto) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"sourceFileDescriptors")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorRequest + compilerVersion__field_descriptor + = Data.ProtoLens.FieldDescriptor + "compiler_version" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor Version) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'compilerVersion")) :: + 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), + (Data.ProtoLens.Tag 17, sourceFileDescriptors__field_descriptor), + (Data.ProtoLens.Tag 3, compilerVersion__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _CodeGeneratorRequest'_unknownFields + (\ x__ y__ -> x__ {_CodeGeneratorRequest'_unknownFields = y__}) + defMessage + = CodeGeneratorRequest'_constructor + {_CodeGeneratorRequest'fileToGenerate = Data.Vector.Generic.empty, + _CodeGeneratorRequest'parameter = Prelude.Nothing, + _CodeGeneratorRequest'protoFile = Data.Vector.Generic.empty, + _CodeGeneratorRequest'sourceFileDescriptors = Data.Vector.Generic.empty, + _CodeGeneratorRequest'compilerVersion = Prelude.Nothing, + _CodeGeneratorRequest'_unknownFields = []} + parseMessage + = let + loop :: + CodeGeneratorRequest + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.Google.Protobuf.Descriptor.FileDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.Google.Protobuf.Descriptor.FileDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorRequest + loop + x + mutable'fileToGenerate + mutable'protoFile + mutable'sourceFileDescriptors + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'fileToGenerate <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'fileToGenerate) + frozen'protoFile <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'protoFile) + frozen'sourceFileDescriptors <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'sourceFileDescriptors) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'fileToGenerate") + frozen'fileToGenerate + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'protoFile") + frozen'protoFile + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'sourceFileDescriptors") + frozen'sourceFileDescriptors + x)))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "file_to_generate" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'fileToGenerate y) + loop x v mutable'protoFile mutable'sourceFileDescriptors + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "parameter" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"parameter") y x) + mutable'fileToGenerate + mutable'protoFile + mutable'sourceFileDescriptors + 122 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "proto_file" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'protoFile y) + loop x mutable'fileToGenerate v mutable'sourceFileDescriptors + 138 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "source_file_descriptors" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'sourceFileDescriptors y) + loop x mutable'fileToGenerate mutable'protoFile v + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "compiler_version" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"compilerVersion") y x) + mutable'fileToGenerate + mutable'protoFile + mutable'sourceFileDescriptors + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'fileToGenerate + mutable'protoFile + mutable'sourceFileDescriptors + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'fileToGenerate <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'protoFile <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'sourceFileDescriptors <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'fileToGenerate + mutable'protoFile + mutable'sourceFileDescriptors) + "CodeGeneratorRequest" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'fileToGenerate") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'parameter") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 122) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'protoFile") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 138) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'sourceFileDescriptors") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'compilerVersion") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData CodeGeneratorRequest where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_CodeGeneratorRequest'_unknownFields x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorRequest'fileToGenerate x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorRequest'parameter x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorRequest'protoFile x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorRequest'sourceFileDescriptors x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorRequest'compilerVersion x__) ()))))) +{- | 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.supportedFeatures' @:: Lens' CodeGeneratorResponse Data.Word.Word64@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'supportedFeatures' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Word.Word64)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.minimumEdition' @:: Lens' CodeGeneratorResponse Data.Int.Int32@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'minimumEdition' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maximumEdition' @:: Lens' CodeGeneratorResponse Data.Int.Int32@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'maximumEdition' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.file' @:: Lens' CodeGeneratorResponse [CodeGeneratorResponse'File]@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'file' @:: Lens' CodeGeneratorResponse (Data.Vector.Vector CodeGeneratorResponse'File)@ -} +data CodeGeneratorResponse + = CodeGeneratorResponse'_constructor {_CodeGeneratorResponse'error :: !(Prelude.Maybe Data.Text.Text), + _CodeGeneratorResponse'supportedFeatures :: !(Prelude.Maybe Data.Word.Word64), + _CodeGeneratorResponse'minimumEdition :: !(Prelude.Maybe Data.Int.Int32), + _CodeGeneratorResponse'maximumEdition :: !(Prelude.Maybe Data.Int.Int32), + _CodeGeneratorResponse'file :: !(Data.Vector.Vector CodeGeneratorResponse'File), + _CodeGeneratorResponse'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show CodeGeneratorResponse where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "error" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'error + (\ x__ y__ -> x__ {_CodeGeneratorResponse'error = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maybe'error" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'error + (\ x__ y__ -> x__ {_CodeGeneratorResponse'error = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "supportedFeatures" Data.Word.Word64 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'supportedFeatures + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'supportedFeatures = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maybe'supportedFeatures" (Prelude.Maybe Data.Word.Word64) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'supportedFeatures + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'supportedFeatures = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "minimumEdition" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'minimumEdition + (\ x__ y__ -> x__ {_CodeGeneratorResponse'minimumEdition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maybe'minimumEdition" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'minimumEdition + (\ x__ y__ -> x__ {_CodeGeneratorResponse'minimumEdition = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maximumEdition" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'maximumEdition + (\ x__ y__ -> x__ {_CodeGeneratorResponse'maximumEdition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maybe'maximumEdition" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'maximumEdition + (\ x__ y__ -> x__ {_CodeGeneratorResponse'maximumEdition = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "file" [CodeGeneratorResponse'File] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'file + (\ x__ y__ -> x__ {_CodeGeneratorResponse'file = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "vec'file" (Data.Vector.Vector CodeGeneratorResponse'File) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'file + (\ x__ y__ -> x__ {_CodeGeneratorResponse'file = y__})) + Prelude.id +instance Data.ProtoLens.Message CodeGeneratorResponse where + messageName _ + = Data.Text.pack "google.protobuf.compiler.CodeGeneratorResponse" + packedMessageDescriptor _ + = "\n\ + \\NAKCodeGeneratorResponse\DC2\DC4\n\ + \\ENQerror\CAN\SOH \SOH(\tR\ENQerror\DC2-\n\ + \\DC2supported_features\CAN\STX \SOH(\EOTR\DC1supportedFeatures\DC2'\n\ + \\SIminimum_edition\CAN\ETX \SOH(\ENQR\SOminimumEdition\DC2'\n\ + \\SImaximum_edition\CAN\EOT \SOH(\ENQR\SOmaximumEdition\DC2H\n\ + \\EOTfile\CAN\SI \ETX(\v24.google.protobuf.compiler.CodeGeneratorResponse.FileR\EOTfile\SUB\177\SOH\n\ + \\EOTFile\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2'\n\ + \\SIinsertion_point\CAN\STX \SOH(\tR\SOinsertionPoint\DC2\CAN\n\ + \\acontent\CAN\SI \SOH(\tR\acontent\DC2R\n\ + \\DC3generated_code_info\CAN\DLE \SOH(\v2\".google.protobuf.GeneratedCodeInfoR\DC1generatedCodeInfo\"W\n\ + \\aFeature\DC2\DLE\n\ + \\fFEATURE_NONE\DLE\NUL\DC2\ESC\n\ + \\ETBFEATURE_PROTO3_OPTIONAL\DLE\SOH\DC2\GS\n\ + \\EMFEATURE_SUPPORTS_EDITIONS\DLE\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + error__field_descriptor + = Data.ProtoLens.FieldDescriptor + "error" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'error")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + supportedFeatures__field_descriptor + = Data.ProtoLens.FieldDescriptor + "supported_features" + (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'supportedFeatures")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + minimumEdition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "minimum_edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'minimumEdition")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + maximumEdition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "maximum_edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'maximumEdition")) :: + 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 (Data.ProtoLens.Field.field @"file")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorResponse + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, error__field_descriptor), + (Data.ProtoLens.Tag 2, supportedFeatures__field_descriptor), + (Data.ProtoLens.Tag 3, minimumEdition__field_descriptor), + (Data.ProtoLens.Tag 4, maximumEdition__field_descriptor), + (Data.ProtoLens.Tag 15, file__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'_unknownFields + (\ x__ y__ -> x__ {_CodeGeneratorResponse'_unknownFields = y__}) + defMessage + = CodeGeneratorResponse'_constructor + {_CodeGeneratorResponse'error = Prelude.Nothing, + _CodeGeneratorResponse'supportedFeatures = Prelude.Nothing, + _CodeGeneratorResponse'minimumEdition = Prelude.Nothing, + _CodeGeneratorResponse'maximumEdition = Prelude.Nothing, + _CodeGeneratorResponse'file = Data.Vector.Generic.empty, + _CodeGeneratorResponse'_unknownFields = []} + parseMessage + = let + loop :: + CodeGeneratorResponse + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld CodeGeneratorResponse'File + -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorResponse + loop x mutable'file + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'file) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'file") frozen'file x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "error" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"error") y x) + mutable'file + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + Data.ProtoLens.Encoding.Bytes.getVarInt "supported_features" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"supportedFeatures") y x) + mutable'file + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "minimum_edition" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"minimumEdition") y x) + mutable'file + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "maximum_edition" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"maximumEdition") y x) + mutable'file + 122 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "file" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'file y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'file + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'file) + "CodeGeneratorResponse" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'error") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'supportedFeatures") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + (Data.ProtoLens.Encoding.Bytes.putVarInt _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'minimumEdition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'maximumEdition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 122) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'file") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData CodeGeneratorResponse where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_CodeGeneratorResponse'_unknownFields x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'error x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'supportedFeatures x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'minimumEdition x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'maximumEdition x__) + (Control.DeepSeq.deepseq (_CodeGeneratorResponse'file x__) ()))))) +data CodeGeneratorResponse'Feature + = CodeGeneratorResponse'FEATURE_NONE | + CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL | + CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum CodeGeneratorResponse'Feature where + maybeToEnum 0 = Prelude.Just CodeGeneratorResponse'FEATURE_NONE + maybeToEnum 1 + = Prelude.Just CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + maybeToEnum 2 + = Prelude.Just CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + maybeToEnum _ = Prelude.Nothing + showEnum CodeGeneratorResponse'FEATURE_NONE = "FEATURE_NONE" + showEnum CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + = "FEATURE_PROTO3_OPTIONAL" + showEnum CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + = "FEATURE_SUPPORTS_EDITIONS" + readEnum k + | (Prelude.==) k "FEATURE_NONE" + = Prelude.Just CodeGeneratorResponse'FEATURE_NONE + | (Prelude.==) k "FEATURE_PROTO3_OPTIONAL" + = Prelude.Just CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + | (Prelude.==) k "FEATURE_SUPPORTS_EDITIONS" + = Prelude.Just CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded CodeGeneratorResponse'Feature where + minBound = CodeGeneratorResponse'FEATURE_NONE + maxBound = CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS +instance Prelude.Enum CodeGeneratorResponse'Feature where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum Feature: " (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum CodeGeneratorResponse'FEATURE_NONE = 0 + fromEnum CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL = 1 + fromEnum CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS = 2 + succ CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + = Prelude.error + "CodeGeneratorResponse'Feature.succ: bad argument CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS. This value would be out of bounds." + succ CodeGeneratorResponse'FEATURE_NONE + = CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + succ CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + = CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + pred CodeGeneratorResponse'FEATURE_NONE + = Prelude.error + "CodeGeneratorResponse'Feature.pred: bad argument CodeGeneratorResponse'FEATURE_NONE. This value would be out of bounds." + pred CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + = CodeGeneratorResponse'FEATURE_NONE + pred CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + = CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + 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 Data.ProtoLens.FieldDefault CodeGeneratorResponse'Feature where + fieldDefault = CodeGeneratorResponse'FEATURE_NONE +instance Control.DeepSeq.NFData CodeGeneratorResponse'Feature where + rnf x__ = Prelude.seq x__ () +{- | 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)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.generatedCodeInfo' @:: Lens' CodeGeneratorResponse'File Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'generatedCodeInfo' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo)@ -} +data CodeGeneratorResponse'File + = CodeGeneratorResponse'File'_constructor {_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'generatedCodeInfo :: !(Prelude.Maybe Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo), + _CodeGeneratorResponse'File'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show CodeGeneratorResponse'File where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'name + (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'name + (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "insertionPoint" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'insertionPoint + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'insertionPoint = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'insertionPoint" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'insertionPoint + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'insertionPoint = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "content" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'content + (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'content = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'content" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'content + (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'content = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "generatedCodeInfo" Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'generatedCodeInfo + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'generatedCodeInfo = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'generatedCodeInfo" (Prelude.Maybe Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'generatedCodeInfo + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'generatedCodeInfo = y__})) + Prelude.id +instance Data.ProtoLens.Message CodeGeneratorResponse'File where + messageName _ + = Data.Text.pack + "google.protobuf.compiler.CodeGeneratorResponse.File" + packedMessageDescriptor _ + = "\n\ + \\EOTFile\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2'\n\ + \\SIinsertion_point\CAN\STX \SOH(\tR\SOinsertionPoint\DC2\CAN\n\ + \\acontent\CAN\SI \SOH(\tR\acontent\DC2R\n\ + \\DC3generated_code_info\CAN\DLE \SOH(\v2\".google.protobuf.GeneratedCodeInfoR\DC1generatedCodeInfo" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'content")) :: + Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File + generatedCodeInfo__field_descriptor + = Data.ProtoLens.FieldDescriptor + "generated_code_info" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor Proto.Google.Protobuf.Descriptor.GeneratedCodeInfo) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'generatedCodeInfo")) :: + 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), + (Data.ProtoLens.Tag 16, generatedCodeInfo__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'_unknownFields + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'_unknownFields = y__}) + defMessage + = CodeGeneratorResponse'File'_constructor + {_CodeGeneratorResponse'File'name = Prelude.Nothing, + _CodeGeneratorResponse'File'insertionPoint = Prelude.Nothing, + _CodeGeneratorResponse'File'content = Prelude.Nothing, + _CodeGeneratorResponse'File'generatedCodeInfo = Prelude.Nothing, + _CodeGeneratorResponse'File'_unknownFields = []} + parseMessage + = let + loop :: + CodeGeneratorResponse'File + -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorResponse'File + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "insertion_point" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"insertionPoint") y x) + 122 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "content" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"content") y x) + 130 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "generated_code_info" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"generatedCodeInfo") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "File" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'insertionPoint") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'content") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 122) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'generatedCodeInfo") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 130) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))) +instance Control.DeepSeq.NFData CodeGeneratorResponse'File where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_CodeGeneratorResponse'File'_unknownFields x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'File'name x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'File'insertionPoint x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'File'content x__) + (Control.DeepSeq.deepseq + (_CodeGeneratorResponse'File'generatedCodeInfo x__) ())))) +{- | Fields : + + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.major' @:: Lens' Version Data.Int.Int32@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'major' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.minor' @:: Lens' Version Data.Int.Int32@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'minor' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.patch' @:: Lens' Version Data.Int.Int32@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'patch' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.suffix' @:: Lens' Version Data.Text.Text@ + * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'suffix' @:: Lens' Version (Prelude.Maybe Data.Text.Text)@ -} +data Version + = Version'_constructor {_Version'major :: !(Prelude.Maybe Data.Int.Int32), + _Version'minor :: !(Prelude.Maybe Data.Int.Int32), + _Version'patch :: !(Prelude.Maybe Data.Int.Int32), + _Version'suffix :: !(Prelude.Maybe Data.Text.Text), + _Version'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show Version where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField Version "major" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'major (\ x__ y__ -> x__ {_Version'major = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField Version "maybe'major" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'major (\ x__ y__ -> x__ {_Version'major = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField Version "minor" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'minor (\ x__ y__ -> x__ {_Version'minor = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField Version "maybe'minor" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'minor (\ x__ y__ -> x__ {_Version'minor = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField Version "patch" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'patch (\ x__ y__ -> x__ {_Version'patch = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField Version "maybe'patch" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'patch (\ x__ y__ -> x__ {_Version'patch = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField Version "suffix" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'suffix (\ x__ y__ -> x__ {_Version'suffix = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField Version "maybe'suffix" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _Version'suffix (\ x__ y__ -> x__ {_Version'suffix = y__})) + Prelude.id +instance Data.ProtoLens.Message Version where + messageName _ = Data.Text.pack "google.protobuf.compiler.Version" + packedMessageDescriptor _ + = "\n\ + \\aVersion\DC2\DC4\n\ + \\ENQmajor\CAN\SOH \SOH(\ENQR\ENQmajor\DC2\DC4\n\ + \\ENQminor\CAN\STX \SOH(\ENQR\ENQminor\DC2\DC4\n\ + \\ENQpatch\CAN\ETX \SOH(\ENQR\ENQpatch\DC2\SYN\n\ + \\ACKsuffix\CAN\EOT \SOH(\tR\ACKsuffix" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + major__field_descriptor + = Data.ProtoLens.FieldDescriptor + "major" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'major")) :: + Data.ProtoLens.FieldDescriptor Version + minor__field_descriptor + = Data.ProtoLens.FieldDescriptor + "minor" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'minor")) :: + Data.ProtoLens.FieldDescriptor Version + patch__field_descriptor + = Data.ProtoLens.FieldDescriptor + "patch" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'patch")) :: + Data.ProtoLens.FieldDescriptor Version + suffix__field_descriptor + = Data.ProtoLens.FieldDescriptor + "suffix" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'suffix")) :: + Data.ProtoLens.FieldDescriptor Version + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, major__field_descriptor), + (Data.ProtoLens.Tag 2, minor__field_descriptor), + (Data.ProtoLens.Tag 3, patch__field_descriptor), + (Data.ProtoLens.Tag 4, suffix__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _Version'_unknownFields + (\ x__ y__ -> x__ {_Version'_unknownFields = y__}) + defMessage + = Version'_constructor + {_Version'major = Prelude.Nothing, + _Version'minor = Prelude.Nothing, _Version'patch = Prelude.Nothing, + _Version'suffix = Prelude.Nothing, _Version'_unknownFields = []} + parseMessage + = let + loop :: Version -> Data.ProtoLens.Encoding.Bytes.Parser Version + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "major" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"major") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "minor" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"minor") y x) + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "patch" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"patch") y x) + 34 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "suffix" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"suffix") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "Version" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'major") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'minor") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'patch") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'suffix") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))) +instance Control.DeepSeq.NFData Version where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_Version'_unknownFields x__) + (Control.DeepSeq.deepseq + (_Version'major x__) + (Control.DeepSeq.deepseq + (_Version'minor x__) + (Control.DeepSeq.deepseq + (_Version'patch x__) + (Control.DeepSeq.deepseq (_Version'suffix x__) ())))) +packedFileDescriptor :: Data.ByteString.ByteString +packedFileDescriptor + = "\n\ + \%google/protobuf/compiler/plugin.proto\DC2\CANgoogle.protobuf.compiler\SUB google/protobuf/descriptor.proto\"c\n\ + \\aVersion\DC2\DC4\n\ + \\ENQmajor\CAN\SOH \SOH(\ENQR\ENQmajor\DC2\DC4\n\ + \\ENQminor\CAN\STX \SOH(\ENQR\ENQminor\DC2\DC4\n\ + \\ENQpatch\CAN\ETX \SOH(\ENQR\ENQpatch\DC2\SYN\n\ + \\ACKsuffix\CAN\EOT \SOH(\tR\ACKsuffix\"\207\STX\n\ + \\DC4CodeGeneratorRequest\DC2(\n\ + \\DLEfile_to_generate\CAN\SOH \ETX(\tR\SOfileToGenerate\DC2\FS\n\ + \\tparameter\CAN\STX \SOH(\tR\tparameter\DC2C\n\ + \\n\ + \proto_file\CAN\SI \ETX(\v2$.google.protobuf.FileDescriptorProtoR\tprotoFile\DC2\\\n\ + \\ETBsource_file_descriptors\CAN\DC1 \ETX(\v2$.google.protobuf.FileDescriptorProtoR\NAKsourceFileDescriptors\DC2L\n\ + \\DLEcompiler_version\CAN\ETX \SOH(\v2!.google.protobuf.compiler.VersionR\SIcompilerVersion\"\133\EOT\n\ + \\NAKCodeGeneratorResponse\DC2\DC4\n\ + \\ENQerror\CAN\SOH \SOH(\tR\ENQerror\DC2-\n\ + \\DC2supported_features\CAN\STX \SOH(\EOTR\DC1supportedFeatures\DC2'\n\ + \\SIminimum_edition\CAN\ETX \SOH(\ENQR\SOminimumEdition\DC2'\n\ + \\SImaximum_edition\CAN\EOT \SOH(\ENQR\SOmaximumEdition\DC2H\n\ + \\EOTfile\CAN\SI \ETX(\v24.google.protobuf.compiler.CodeGeneratorResponse.FileR\EOTfile\SUB\177\SOH\n\ + \\EOTFile\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2'\n\ + \\SIinsertion_point\CAN\STX \SOH(\tR\SOinsertionPoint\DC2\CAN\n\ + \\acontent\CAN\SI \SOH(\tR\acontent\DC2R\n\ + \\DC3generated_code_info\CAN\DLE \SOH(\v2\".google.protobuf.GeneratedCodeInfoR\DC1generatedCodeInfo\"W\n\ + \\aFeature\DC2\DLE\n\ + \\fFEATURE_NONE\DLE\NUL\DC2\ESC\n\ + \\ETBFEATURE_PROTO3_OPTIONAL\DLE\SOH\DC2\GS\n\ + \\EMFEATURE_SUPPORTS_EDITIONS\DLE\STXBr\n\ + \\FScom.google.protobuf.compilerB\fPluginProtosZ)google.golang.org/protobuf/types/pluginpb\170\STX\CANGoogle.Protobuf.CompilerJ\226B\n\ + \\a\DC2\ENQ\DC4\NUL\179\SOH\SOH\n\ + \\186\ACK\n\ + \\SOH\f\DC2\ETX\DC4\NUL\DC22\137\STX Protocol Buffers - Google's data interchange format\n\ + \ Copyright 2008 Google Inc. All rights reserved.\n\ + \\n\ + \ Use of this source code is governed by a BSD-style\n\ + \ license that can be found in the LICENSE file or at\n\ + \ https://developers.google.com/open-source/licenses/bsd\n\ + \2\163\EOT Author: kenton@google.com (Kenton Varda)\n\ + \\n\ + \ protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is\n\ + \ just a program that reads a CodeGeneratorRequest from stdin and writes a\n\ + \ CodeGeneratorResponse to stdout.\n\ + \\n\ + \ Plugins written using C++ can use google/protobuf/compiler/plugin.h instead\n\ + \ of dealing with the raw protocol defined here.\n\ + \\n\ + \ A plugin executable needs only to be placed somewhere in the path. The\n\ + \ plugin should be named \"protoc-gen-$NAME\", and will then be used when the\n\ + \ flag \"--${NAME}_out\" is passed to protoc.\n\ + \\n\ + \\b\n\ + \\SOH\STX\DC2\ETX\SYN\NUL!\n\ + \\b\n\ + \\SOH\b\DC2\ETX\ETB\NUL5\n\ + \\t\n\ + \\STX\b\SOH\DC2\ETX\ETB\NUL5\n\ + \\b\n\ + \\SOH\b\DC2\ETX\CAN\NUL-\n\ + \\t\n\ + \\STX\b\b\DC2\ETX\CAN\NUL-\n\ + \\b\n\ + \\SOH\b\DC2\ETX\SUB\NUL5\n\ + \\t\n\ + \\STX\b%\DC2\ETX\SUB\NUL5\n\ + \\b\n\ + \\SOH\b\DC2\ETX\ESC\NUL@\n\ + \\t\n\ + \\STX\b\v\DC2\ETX\ESC\NUL@\n\ + \\t\n\ + \\STX\ETX\NUL\DC2\ETX\GS\NUL*\n\ + \6\n\ + \\STX\EOT\NUL\DC2\EOT \NUL'\SOH\SUB* The version number of protocol compiler.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\EOT\NUL\SOH\DC2\ETX \b\SI\n\ + \\v\n\ + \\EOT\EOT\NUL\STX\NUL\DC2\ETX!\STX\ESC\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\EOT\DC2\ETX!\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\ENQ\DC2\ETX!\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\ETX!\DC1\SYN\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\ETX!\EM\SUB\n\ + \\v\n\ + \\EOT\EOT\NUL\STX\SOH\DC2\ETX\"\STX\ESC\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\SOH\EOT\DC2\ETX\"\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\SOH\ENQ\DC2\ETX\"\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\SOH\SOH\DC2\ETX\"\DC1\SYN\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\SOH\ETX\DC2\ETX\"\EM\SUB\n\ + \\v\n\ + \\EOT\EOT\NUL\STX\STX\DC2\ETX#\STX\ESC\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\STX\EOT\DC2\ETX#\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\STX\ENQ\DC2\ETX#\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\STX\SOH\DC2\ETX#\DC1\SYN\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\STX\ETX\DC2\ETX#\EM\SUB\n\ + \\128\SOH\n\ + \\EOT\EOT\NUL\STX\ETX\DC2\ETX&\STX\GS\SUBs A suffix for alpha, beta or rc release, e.g., \"alpha-1\", \"rc2\". It should\n\ + \ be empty for mainline stable releases.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\ETX\EOT\DC2\ETX&\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\ETX\ENQ\DC2\ETX&\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\ETX\SOH\DC2\ETX&\DC2\CAN\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\ETX\ETX\DC2\ETX&\ESC\FS\n\ + \O\n\ + \\STX\EOT\SOH\DC2\EOT*\NULO\SOH\SUBC An encoded CodeGeneratorRequest is written to the plugin's stdin.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\EOT\SOH\SOH\DC2\ETX*\b\FS\n\ + \\209\SOH\n\ + \\EOT\EOT\SOH\STX\NUL\DC2\ETX.\STX'\SUB\195\SOH The .proto files that were explicitly listed on the command-line. The\n\ + \ code generator should generate code only for these files. Each file's\n\ + \ descriptor will be included in proto_file, below.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\EOT\DC2\ETX.\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\ENQ\DC2\ETX.\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\SOH\DC2\ETX.\DC2\"\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\ETX\DC2\ETX.%&\n\ + \B\n\ + \\EOT\EOT\SOH\STX\SOH\DC2\ETX1\STX \SUB5 The generator parameter passed on the command-line.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\EOT\DC2\ETX1\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\ENQ\DC2\ETX1\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\SOH\DC2\ETX1\DC2\ESC\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\ETX\DC2\ETX1\RS\US\n\ + \\150\b\n\ + \\EOT\EOT\SOH\STX\STX\DC2\ETXF\STX/\SUB\136\b FileDescriptorProtos for all files in files_to_generate and everything\n\ + \ they import. The files will appear in topological order, so each file\n\ + \ appears before any file that imports it.\n\ + \\n\ + \ Note: the files listed in files_to_generate will include runtime-retention\n\ + \ options only, but all other files will include source-retention options.\n\ + \ The source_file_descriptors field below is available in case you need\n\ + \ source-retention options for files_to_generate.\n\ + \\n\ + \ protoc guarantees that all proto_files will be written after\n\ + \ the fields above, even though this is not technically guaranteed by the\n\ + \ protobuf wire format. This theoretically could allow a plugin to stream\n\ + \ in the FileDescriptorProtos and handle them one by one rather than read\n\ + \ the entire set into memory at once. However, as of this writing, this\n\ + \ is not similarly optimized on protoc's end -- it will store all fields in\n\ + \ memory at once before sending them to the plugin.\n\ + \\n\ + \ Type names of fields and extensions in the FileDescriptorProto are always\n\ + \ fully qualified.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\EOT\DC2\ETXF\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\ACK\DC2\ETXF\v\RS\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\SOH\DC2\ETXF\US)\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\ETX\DC2\ETXF,.\n\ + \\167\SOH\n\ + \\EOT\EOT\SOH\STX\ETX\DC2\ETXK\STX<\SUB\153\SOH File descriptors with all options, including source-retention options.\n\ + \ These descriptors are only provided for the files listed in\n\ + \ files_to_generate.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\EOT\DC2\ETXK\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\ACK\DC2\ETXK\v\RS\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\SOH\DC2\ETXK\US6\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\ETX\DC2\ETXK9;\n\ + \7\n\ + \\EOT\EOT\SOH\STX\EOT\DC2\ETXN\STX(\SUB* The version number of protocol compiler.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\EOT\DC2\ETXN\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\ACK\DC2\ETXN\v\DC2\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\SOH\DC2\ETXN\DC3#\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\ETX\DC2\ETXN&'\n\ + \L\n\ + \\STX\EOT\STX\DC2\ENQR\NUL\179\SOH\SOH\SUB? The plugin writes an encoded CodeGeneratorResponse to stdout.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\EOT\STX\SOH\DC2\ETXR\b\GS\n\ + \\237\ETX\n\ + \\EOT\EOT\STX\STX\NUL\DC2\ETX[\STX\FS\SUB\223\ETX Error message. If non-empty, code generation failed. The plugin process\n\ + \ should exit with status code zero even if it reports an error in this way.\n\ + \\n\ + \ This should be used to indicate errors in .proto files which prevent the\n\ + \ code generator from generating correct code. Errors which indicate a\n\ + \ problem in protoc itself -- such as the input CodeGeneratorRequest being\n\ + \ unparseable -- should be reported by writing a message to stderr and\n\ + \ exiting with a non-zero status code.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\NUL\EOT\DC2\ETX[\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\NUL\ENQ\DC2\ETX[\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\NUL\SOH\DC2\ETX[\DC2\ETB\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\NUL\ETX\DC2\ETX[\SUB\ESC\n\ + \\137\SOH\n\ + \\EOT\EOT\STX\STX\SOH\DC2\ETX_\STX)\SUB| A bitmask of supported features that the code generator supports.\n\ + \ This is a bitwise \"or\" of values from the Feature enum.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\SOH\EOT\DC2\ETX_\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\SOH\ENQ\DC2\ETX_\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\SOH\SOH\DC2\ETX_\DC2$\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\SOH\ETX\DC2\ETX_'(\n\ + \+\n\ + \\EOT\EOT\STX\EOT\NUL\DC2\EOTb\STXf\ETX\SUB\GS Sync with code_generator.h.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\EOT\NUL\SOH\DC2\ETXb\a\SO\n\ + \\r\n\ + \\ACK\EOT\STX\EOT\NUL\STX\NUL\DC2\ETXc\EOT\NAK\n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\NUL\SOH\DC2\ETXc\EOT\DLE\n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\NUL\STX\DC2\ETXc\DC3\DC4\n\ + \\r\n\ + \\ACK\EOT\STX\EOT\NUL\STX\SOH\DC2\ETXd\EOT \n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\SOH\SOH\DC2\ETXd\EOT\ESC\n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\SOH\STX\DC2\ETXd\RS\US\n\ + \\r\n\ + \\ACK\EOT\STX\EOT\NUL\STX\STX\DC2\ETXe\EOT\"\n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\STX\SOH\DC2\ETXe\EOT\GS\n\ + \\SO\n\ + \\a\EOT\STX\EOT\NUL\STX\STX\STX\DC2\ETXe !\n\ + \\167\STX\n\ + \\EOT\EOT\STX\STX\STX\DC2\ETXl\STX%\SUB\153\STX The minimum edition this plugin supports. This will be treated as an\n\ + \ Edition enum, but we want to allow unknown values. It should be specified\n\ + \ according the edition enum value, *not* the edition number. Only takes\n\ + \ effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\STX\EOT\DC2\ETXl\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\STX\ENQ\DC2\ETXl\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\STX\SOH\DC2\ETXl\DC1 \n\ + \\f\n\ + \\ENQ\EOT\STX\STX\STX\ETX\DC2\ETXl#$\n\ + \\167\STX\n\ + \\EOT\EOT\STX\STX\ETX\DC2\ETXr\STX%\SUB\153\STX The maximum edition this plugin supports. This will be treated as an\n\ + \ Edition enum, but we want to allow unknown values. It should be specified\n\ + \ according the edition enum value, *not* the edition number. Only takes\n\ + \ effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\ETX\EOT\DC2\ETXr\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\ETX\ENQ\DC2\ETXr\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\STX\STX\ETX\SOH\DC2\ETXr\DC1 \n\ + \\f\n\ + \\ENQ\EOT\STX\STX\ETX\ETX\DC2\ETXr#$\n\ + \4\n\ + \\EOT\EOT\STX\ETX\NUL\DC2\ENQu\STX\177\SOH\ETX\SUB% Represents a single generated file.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\STX\ETX\NUL\SOH\DC2\ETXu\n\ + \\SO\n\ + \\174\ENQ\n\ + \\ACK\EOT\STX\ETX\NUL\STX\NUL\DC2\EOT\129\SOH\EOT\GS\SUB\157\ENQ The file name, relative to the output directory. The name must not\n\ + \ contain \".\" or \"..\" components and must be relative, not be absolute (so,\n\ + \ the file cannot lie outside the output directory). \"/\" must be used as\n\ + \ the path separator, not \"\\\".\n\ + \\n\ + \ If the name is omitted, the content will be appended to the previous\n\ + \ file. This allows the generator to break large files into small chunks,\n\ + \ and allows the generated text to be streamed back to protoc so that large\n\ + \ files need not reside completely in memory at one time. Note that as of\n\ + \ this writing protoc does not optimize for this -- it will read the entire\n\ + \ CodeGeneratorResponse before writing files to disk.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\EOT\DC2\EOT\129\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\ENQ\DC2\EOT\129\SOH\r\DC3\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\SOH\DC2\EOT\129\SOH\DC4\CAN\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\ETX\DC2\EOT\129\SOH\ESC\FS\n\ + \\174\DLE\n\ + \\ACK\EOT\STX\ETX\NUL\STX\SOH\DC2\EOT\168\SOH\EOT(\SUB\157\DLE If non-empty, indicates that the named file should already exist, and the\n\ + \ content here is to be inserted into that file at a defined insertion\n\ + \ point. This feature allows a code generator to extend the output\n\ + \ produced by another code generator. The original generator may provide\n\ + \ insertion points by placing special annotations in the file that look\n\ + \ like:\n\ + \ @@protoc_insertion_point(NAME)\n\ + \ The annotation can have arbitrary text before and after it on the line,\n\ + \ which allows it to be placed in a comment. NAME should be replaced with\n\ + \ an identifier naming the point -- this is what other generators will use\n\ + \ as the insertion_point. Code inserted at this point will be placed\n\ + \ immediately above the line containing the insertion point (thus multiple\n\ + \ insertions to the same point will come out in the order they were added).\n\ + \ The double-@ is intended to make it unlikely that the generated code\n\ + \ could contain things that look like insertion points by accident.\n\ + \\n\ + \ For example, the C++ code generator places the following line in the\n\ + \ .pb.h files that it generates:\n\ + \ // @@protoc_insertion_point(namespace_scope)\n\ + \ This line appears within the scope of the file's package namespace, but\n\ + \ outside of any particular class. Another plugin can then specify the\n\ + \ insertion_point \"namespace_scope\" to generate additional classes or\n\ + \ other declarations that should be placed in this scope.\n\ + \\n\ + \ Note that if the line containing the insertion point begins with\n\ + \ whitespace, the same whitespace will be added to every line of the\n\ + \ inserted text. This is useful for languages like Python, where\n\ + \ indentation matters. In these languages, the insertion point comment\n\ + \ should be indented the same amount as any inserted code will need to be\n\ + \ in order to work correctly in that context.\n\ + \\n\ + \ The code generator that generates the initial file and the one which\n\ + \ inserts into it must both run as part of a single invocation of protoc.\n\ + \ Code generators are executed in the order in which they appear on the\n\ + \ command line.\n\ + \\n\ + \ If |insertion_point| is present, |name| must also be present.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\EOT\DC2\EOT\168\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\ENQ\DC2\EOT\168\SOH\r\DC3\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\SOH\DC2\EOT\168\SOH\DC4#\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\ETX\DC2\EOT\168\SOH&'\n\ + \$\n\ + \\ACK\EOT\STX\ETX\NUL\STX\STX\DC2\EOT\171\SOH\EOT!\SUB\DC4 The file contents.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\EOT\DC2\EOT\171\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\ENQ\DC2\EOT\171\SOH\r\DC3\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\SOH\DC2\EOT\171\SOH\DC4\ESC\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\ETX\DC2\EOT\171\SOH\RS \n\ + \\225\SOH\n\ + \\ACK\EOT\STX\ETX\NUL\STX\ETX\DC2\EOT\176\SOH\EOT8\SUB\208\SOH Information describing the file content being inserted. If an insertion\n\ + \ point is used, this information will be appropriately offset and inserted\n\ + \ into the code generation metadata for the generated files.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\ETX\EOT\DC2\EOT\176\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\ETX\ACK\DC2\EOT\176\SOH\r\RS\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\ETX\SOH\DC2\EOT\176\SOH\US2\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\ETX\ETX\DC2\EOT\176\SOH57\n\ + \\f\n\ + \\EOT\EOT\STX\STX\EOT\DC2\EOT\178\SOH\STX\SUB\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\EOT\DC2\EOT\178\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\ACK\DC2\EOT\178\SOH\v\SI\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\SOH\DC2\EOT\178\SOH\DLE\DC4\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\ETX\DC2\EOT\178\SOH\ETB\EM" diff --git a/app/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs b/app/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs new file mode 100644 --- /dev/null +++ b/app/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs @@ -0,0 +1,247 @@ +{- 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, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-} +{-# OPTIONS_GHC -Wno-unused-imports#-} +{-# OPTIONS_GHC -Wno-duplicate-exports#-} +{-# OPTIONS_GHC -Wno-dodgy-exports#-} +module Proto.Google.Protobuf.Compiler.Plugin_Fields where +import qualified Data.ProtoLens.Runtime.Prelude as Prelude +import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int +import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid +import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word +import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types +import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2 +import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text +import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map +import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString +import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8 +import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding +import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector +import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic +import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed +import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read +import qualified Proto.Google.Protobuf.Descriptor +compilerVersion :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "compilerVersion" a) => + Lens.Family2.LensLike' f s a +compilerVersion = Data.ProtoLens.Field.field @"compilerVersion" +content :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "content" a) => + Lens.Family2.LensLike' f s a +content = Data.ProtoLens.Field.field @"content" +error :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "error" a) => + Lens.Family2.LensLike' f s a +error = Data.ProtoLens.Field.field @"error" +file :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "file" a) => + Lens.Family2.LensLike' f s a +file = Data.ProtoLens.Field.field @"file" +fileToGenerate :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "fileToGenerate" a) => + Lens.Family2.LensLike' f s a +fileToGenerate = Data.ProtoLens.Field.field @"fileToGenerate" +generatedCodeInfo :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "generatedCodeInfo" a) => + Lens.Family2.LensLike' f s a +generatedCodeInfo = Data.ProtoLens.Field.field @"generatedCodeInfo" +insertionPoint :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "insertionPoint" a) => + Lens.Family2.LensLike' f s a +insertionPoint = Data.ProtoLens.Field.field @"insertionPoint" +major :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "major" a) => + Lens.Family2.LensLike' f s a +major = Data.ProtoLens.Field.field @"major" +maximumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maximumEdition" a) => + Lens.Family2.LensLike' f s a +maximumEdition = Data.ProtoLens.Field.field @"maximumEdition" +maybe'compilerVersion :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'compilerVersion" a) => + Lens.Family2.LensLike' f s a +maybe'compilerVersion + = Data.ProtoLens.Field.field @"maybe'compilerVersion" +maybe'content :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'content" a) => + Lens.Family2.LensLike' f s a +maybe'content = Data.ProtoLens.Field.field @"maybe'content" +maybe'error :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'error" a) => + Lens.Family2.LensLike' f s a +maybe'error = Data.ProtoLens.Field.field @"maybe'error" +maybe'generatedCodeInfo :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'generatedCodeInfo" a) => + Lens.Family2.LensLike' f s a +maybe'generatedCodeInfo + = Data.ProtoLens.Field.field @"maybe'generatedCodeInfo" +maybe'insertionPoint :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'insertionPoint" a) => + Lens.Family2.LensLike' f s a +maybe'insertionPoint + = Data.ProtoLens.Field.field @"maybe'insertionPoint" +maybe'major :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'major" a) => + Lens.Family2.LensLike' f s a +maybe'major = Data.ProtoLens.Field.field @"maybe'major" +maybe'maximumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'maximumEdition" a) => + Lens.Family2.LensLike' f s a +maybe'maximumEdition + = Data.ProtoLens.Field.field @"maybe'maximumEdition" +maybe'minimumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'minimumEdition" a) => + Lens.Family2.LensLike' f s a +maybe'minimumEdition + = Data.ProtoLens.Field.field @"maybe'minimumEdition" +maybe'minor :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'minor" a) => + Lens.Family2.LensLike' f s a +maybe'minor = Data.ProtoLens.Field.field @"maybe'minor" +maybe'name :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'name" a) => + Lens.Family2.LensLike' f s a +maybe'name = Data.ProtoLens.Field.field @"maybe'name" +maybe'parameter :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'parameter" a) => + Lens.Family2.LensLike' f s a +maybe'parameter = Data.ProtoLens.Field.field @"maybe'parameter" +maybe'patch :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'patch" a) => + Lens.Family2.LensLike' f s a +maybe'patch = Data.ProtoLens.Field.field @"maybe'patch" +maybe'suffix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'suffix" a) => + Lens.Family2.LensLike' f s a +maybe'suffix = Data.ProtoLens.Field.field @"maybe'suffix" +maybe'supportedFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'supportedFeatures" a) => + Lens.Family2.LensLike' f s a +maybe'supportedFeatures + = Data.ProtoLens.Field.field @"maybe'supportedFeatures" +minimumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "minimumEdition" a) => + Lens.Family2.LensLike' f s a +minimumEdition = Data.ProtoLens.Field.field @"minimumEdition" +minor :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "minor" a) => + Lens.Family2.LensLike' f s a +minor = Data.ProtoLens.Field.field @"minor" +name :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "name" a) => + Lens.Family2.LensLike' f s a +name = Data.ProtoLens.Field.field @"name" +parameter :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "parameter" a) => + Lens.Family2.LensLike' f s a +parameter = Data.ProtoLens.Field.field @"parameter" +patch :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "patch" a) => + Lens.Family2.LensLike' f s a +patch = Data.ProtoLens.Field.field @"patch" +protoFile :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "protoFile" a) => + Lens.Family2.LensLike' f s a +protoFile = Data.ProtoLens.Field.field @"protoFile" +sourceFileDescriptors :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "sourceFileDescriptors" a) => + Lens.Family2.LensLike' f s a +sourceFileDescriptors + = Data.ProtoLens.Field.field @"sourceFileDescriptors" +suffix :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "suffix" a) => + Lens.Family2.LensLike' f s a +suffix = Data.ProtoLens.Field.field @"suffix" +supportedFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "supportedFeatures" a) => + Lens.Family2.LensLike' f s a +supportedFeatures = Data.ProtoLens.Field.field @"supportedFeatures" +vec'file :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'file" a) => + Lens.Family2.LensLike' f s a +vec'file = Data.ProtoLens.Field.field @"vec'file" +vec'fileToGenerate :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'fileToGenerate" a) => + Lens.Family2.LensLike' f s a +vec'fileToGenerate + = Data.ProtoLens.Field.field @"vec'fileToGenerate" +vec'protoFile :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'protoFile" a) => + Lens.Family2.LensLike' f s a +vec'protoFile = Data.ProtoLens.Field.field @"vec'protoFile" +vec'sourceFileDescriptors :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'sourceFileDescriptors" a) => + Lens.Family2.LensLike' f s a +vec'sourceFileDescriptors + = Data.ProtoLens.Field.field @"vec'sourceFileDescriptors" diff --git a/app/Proto/Google/Protobuf/Descriptor.hs b/app/Proto/Google/Protobuf/Descriptor.hs new file mode 100644 --- /dev/null +++ b/app/Proto/Google/Protobuf/Descriptor.hs @@ -0,0 +1,18329 @@ +{- 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, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-} +{-# OPTIONS_GHC -Wno-unused-imports#-} +{-# OPTIONS_GHC -Wno-duplicate-exports#-} +{-# OPTIONS_GHC -Wno-dodgy-exports#-} +module Proto.Google.Protobuf.Descriptor ( + DescriptorProto(), DescriptorProto'ExtensionRange(), + DescriptorProto'ReservedRange(), Edition(..), Edition(), + EnumDescriptorProto(), EnumDescriptorProto'EnumReservedRange(), + EnumOptions(), EnumValueDescriptorProto(), EnumValueOptions(), + ExtensionRangeOptions(), ExtensionRangeOptions'Declaration(), + ExtensionRangeOptions'VerificationState(..), + ExtensionRangeOptions'VerificationState(), FeatureSet(), + FeatureSet'EnumType(..), FeatureSet'EnumType(), + FeatureSet'FieldPresence(..), FeatureSet'FieldPresence(), + FeatureSet'JsonFormat(..), FeatureSet'JsonFormat(), + FeatureSet'MessageEncoding(..), FeatureSet'MessageEncoding(), + FeatureSet'RepeatedFieldEncoding(..), + FeatureSet'RepeatedFieldEncoding(), FeatureSet'Utf8Validation(..), + FeatureSet'Utf8Validation(), FeatureSetDefaults(), + FeatureSetDefaults'FeatureSetEditionDefault(), + FieldDescriptorProto(), FieldDescriptorProto'Label(..), + FieldDescriptorProto'Label(), FieldDescriptorProto'Type(..), + FieldDescriptorProto'Type(), FieldOptions(), + FieldOptions'CType(..), FieldOptions'CType(), + FieldOptions'EditionDefault(), FieldOptions'FeatureSupport(), + FieldOptions'JSType(..), FieldOptions'JSType(), + FieldOptions'OptionRetention(..), FieldOptions'OptionRetention(), + FieldOptions'OptionTargetType(..), FieldOptions'OptionTargetType(), + FileDescriptorProto(), FileDescriptorSet(), FileOptions(), + FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(), + GeneratedCodeInfo(), GeneratedCodeInfo'Annotation(), + GeneratedCodeInfo'Annotation'Semantic(..), + GeneratedCodeInfo'Annotation'Semantic(), MessageOptions(), + MethodDescriptorProto(), MethodOptions(), + MethodOptions'IdempotencyLevel(..), + MethodOptions'IdempotencyLevel(), OneofDescriptorProto(), + OneofOptions(), ServiceDescriptorProto(), ServiceOptions(), + SourceCodeInfo(), SourceCodeInfo'Location(), UninterpretedOption(), + UninterpretedOption'NamePart() + ) where +import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism +import qualified Data.ProtoLens.Runtime.Prelude as Prelude +import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int +import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid +import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word +import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types +import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2 +import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text +import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map +import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString +import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8 +import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding +import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector +import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic +import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed +import qualified Data.ProtoLens.Runtime.Text.Read as 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.vec'field' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' DescriptorProto [FieldDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extension' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.nestedType' @:: Lens' DescriptorProto [DescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'nestedType' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' DescriptorProto [EnumDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'enumType' @:: Lens' DescriptorProto (Data.Vector.Vector EnumDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extensionRange' @:: Lens' DescriptorProto [DescriptorProto'ExtensionRange]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extensionRange' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto'ExtensionRange)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.oneofDecl' @:: Lens' DescriptorProto [OneofDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'oneofDecl' @:: Lens' DescriptorProto (Data.Vector.Vector 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.vec'reservedRange' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto'ReservedRange)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' DescriptorProto [Data.Text.Text]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' DescriptorProto (Data.Vector.Vector Data.Text.Text)@ -} +data DescriptorProto + = DescriptorProto'_constructor {_DescriptorProto'name :: !(Prelude.Maybe Data.Text.Text), + _DescriptorProto'field :: !(Data.Vector.Vector FieldDescriptorProto), + _DescriptorProto'extension :: !(Data.Vector.Vector FieldDescriptorProto), + _DescriptorProto'nestedType :: !(Data.Vector.Vector DescriptorProto), + _DescriptorProto'enumType :: !(Data.Vector.Vector EnumDescriptorProto), + _DescriptorProto'extensionRange :: !(Data.Vector.Vector DescriptorProto'ExtensionRange), + _DescriptorProto'oneofDecl :: !(Data.Vector.Vector OneofDescriptorProto), + _DescriptorProto'options :: !(Prelude.Maybe MessageOptions), + _DescriptorProto'reservedRange :: !(Data.Vector.Vector DescriptorProto'ReservedRange), + _DescriptorProto'reservedName :: !(Data.Vector.Vector Data.Text.Text), + _DescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show DescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField DescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'name + (\ x__ y__ -> x__ {_DescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField DescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'name + (\ x__ y__ -> x__ {_DescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "field" [FieldDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'field + (\ x__ y__ -> x__ {_DescriptorProto'field = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'field" (Data.Vector.Vector FieldDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'field + (\ x__ y__ -> x__ {_DescriptorProto'field = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "extension" [FieldDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'extension + (\ x__ y__ -> x__ {_DescriptorProto'extension = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'extension" (Data.Vector.Vector FieldDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'extension + (\ x__ y__ -> x__ {_DescriptorProto'extension = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "nestedType" [DescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'nestedType + (\ x__ y__ -> x__ {_DescriptorProto'nestedType = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'nestedType" (Data.Vector.Vector DescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'nestedType + (\ x__ y__ -> x__ {_DescriptorProto'nestedType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "enumType" [EnumDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'enumType + (\ x__ y__ -> x__ {_DescriptorProto'enumType = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'enumType" (Data.Vector.Vector EnumDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'enumType + (\ x__ y__ -> x__ {_DescriptorProto'enumType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "extensionRange" [DescriptorProto'ExtensionRange] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'extensionRange + (\ x__ y__ -> x__ {_DescriptorProto'extensionRange = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'extensionRange" (Data.Vector.Vector DescriptorProto'ExtensionRange) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'extensionRange + (\ x__ y__ -> x__ {_DescriptorProto'extensionRange = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "oneofDecl" [OneofDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'oneofDecl + (\ x__ y__ -> x__ {_DescriptorProto'oneofDecl = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'oneofDecl" (Data.Vector.Vector OneofDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'oneofDecl + (\ x__ y__ -> x__ {_DescriptorProto'oneofDecl = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "options" MessageOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'options + (\ x__ y__ -> x__ {_DescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField DescriptorProto "maybe'options" (Prelude.Maybe MessageOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'options + (\ x__ y__ -> x__ {_DescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "reservedRange" [DescriptorProto'ReservedRange] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'reservedRange + (\ x__ y__ -> x__ {_DescriptorProto'reservedRange = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'reservedRange" (Data.Vector.Vector DescriptorProto'ReservedRange) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'reservedRange + (\ x__ y__ -> x__ {_DescriptorProto'reservedRange = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto "reservedName" [Data.Text.Text] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'reservedName + (\ x__ y__ -> x__ {_DescriptorProto'reservedName = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField DescriptorProto "vec'reservedName" (Data.Vector.Vector Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'reservedName + (\ x__ y__ -> x__ {_DescriptorProto'reservedName = y__})) + Prelude.id +instance Data.ProtoLens.Message DescriptorProto where + messageName _ = Data.Text.pack "google.protobuf.DescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\SIDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2;\n\ + \\ENQfield\CAN\STX \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\ENQfield\DC2C\n\ + \\textension\CAN\ACK \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\textension\DC2A\n\ + \\vnested_type\CAN\ETX \ETX(\v2 .google.protobuf.DescriptorProtoR\n\ + \nestedType\DC2A\n\ + \\tenum_type\CAN\EOT \ETX(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\DC2X\n\ + \\SIextension_range\CAN\ENQ \ETX(\v2/.google.protobuf.DescriptorProto.ExtensionRangeR\SOextensionRange\DC2D\n\ + \\n\ + \oneof_decl\CAN\b \ETX(\v2%.google.protobuf.OneofDescriptorProtoR\toneofDecl\DC29\n\ + \\aoptions\CAN\a \SOH(\v2\US.google.protobuf.MessageOptionsR\aoptions\DC2U\n\ + \\SOreserved_range\CAN\t \ETX(\v2..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\DC2#\n\ + \\rreserved_name\CAN\n\ + \ \ETX(\tR\freservedName\SUBz\n\ + \\SOExtensionRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend\DC2@\n\ + \\aoptions\CAN\ETX \SOH(\v2&.google.protobuf.ExtensionRangeOptionsR\aoptions\SUB7\n\ + \\rReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = DescriptorProto'_constructor + {_DescriptorProto'name = Prelude.Nothing, + _DescriptorProto'field = Data.Vector.Generic.empty, + _DescriptorProto'extension = Data.Vector.Generic.empty, + _DescriptorProto'nestedType = Data.Vector.Generic.empty, + _DescriptorProto'enumType = Data.Vector.Generic.empty, + _DescriptorProto'extensionRange = Data.Vector.Generic.empty, + _DescriptorProto'oneofDecl = Data.Vector.Generic.empty, + _DescriptorProto'options = Prelude.Nothing, + _DescriptorProto'reservedRange = Data.Vector.Generic.empty, + _DescriptorProto'reservedName = Data.Vector.Generic.empty, + _DescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + DescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto'ExtensionRange + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld OneofDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto'ReservedRange + -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'enumType) + frozen'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'extension) + frozen'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'extensionRange) + frozen'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'field) + frozen'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'nestedType) + frozen'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'oneofDecl) + frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'reservedName) + frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'reservedRange) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'enumType") + frozen'enumType + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'extension") + frozen'extension + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'extensionRange") + frozen'extensionRange + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'field") + frozen'field + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'nestedType") + frozen'nestedType + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'oneofDecl") + frozen'oneofDecl + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'reservedName") + frozen'reservedName + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'reservedRange") + frozen'reservedRange + x))))))))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 18 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "field" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'field y) + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + v + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 50 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "extension" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'extension y) + loop + x + mutable'enumType + v + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 26 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "nested_type" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'nestedType y) + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + v + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 34 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "enum_type" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'enumType y) + loop + x + v + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 42 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "extension_range" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'extensionRange y) + loop + x + mutable'enumType + mutable'extension + v + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 66 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "oneof_decl" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'oneofDecl y) + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + v + mutable'reservedName + mutable'reservedRange + 58 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + 74 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "reserved_range" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'reservedRange y) + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + v + 82 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "reserved_name" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'reservedName y) + loop + x + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + v + mutable'reservedRange + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'enumType + mutable'extension + mutable'extensionRange + mutable'field + mutable'nestedType + mutable'oneofDecl + mutable'reservedName + mutable'reservedRange) + "DescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'field") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 50) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'extension") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'nestedType") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'enumType") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 42) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'extensionRange") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 66) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'oneofDecl") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 58) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 74) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'reservedRange") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 82) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'reservedName") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view + Data.ProtoLens.unknownFields _x))))))))))) +instance Control.DeepSeq.NFData DescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_DescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'field x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'extension x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'nestedType x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'enumType x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'extensionRange x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'oneofDecl x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'options x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'reservedRange x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'reservedName x__) ())))))))))) +{- | 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)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto'ExtensionRange ExtensionRangeOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe ExtensionRangeOptions)@ -} +data DescriptorProto'ExtensionRange + = DescriptorProto'ExtensionRange'_constructor {_DescriptorProto'ExtensionRange'start :: !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ExtensionRange'end :: !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ExtensionRange'options :: !(Prelude.Maybe ExtensionRangeOptions), + _DescriptorProto'ExtensionRange'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show DescriptorProto'ExtensionRange where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "start" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'start + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'start = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'start + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'start = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "end" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'end + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'end + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'end = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "options" ExtensionRangeOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'options + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'options" (Prelude.Maybe ExtensionRangeOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'options + (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'options = y__})) + Prelude.id +instance Data.ProtoLens.Message DescriptorProto'ExtensionRange where + messageName _ + = Data.Text.pack "google.protobuf.DescriptorProto.ExtensionRange" + packedMessageDescriptor _ + = "\n\ + \\SOExtensionRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend\DC2@\n\ + \\aoptions\CAN\ETX \SOH(\v2&.google.protobuf.ExtensionRangeOptionsR\aoptions" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + start__field_descriptor + = Data.ProtoLens.FieldDescriptor + "start" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'end")) :: + Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange + options__field_descriptor + = Data.ProtoLens.FieldDescriptor + "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor ExtensionRangeOptions) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'options")) :: + Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, start__field_descriptor), + (Data.ProtoLens.Tag 2, end__field_descriptor), + (Data.ProtoLens.Tag 3, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _DescriptorProto'ExtensionRange'_unknownFields + (\ x__ y__ + -> x__ {_DescriptorProto'ExtensionRange'_unknownFields = y__}) + defMessage + = DescriptorProto'ExtensionRange'_constructor + {_DescriptorProto'ExtensionRange'start = Prelude.Nothing, + _DescriptorProto'ExtensionRange'end = Prelude.Nothing, + _DescriptorProto'ExtensionRange'options = Prelude.Nothing, + _DescriptorProto'ExtensionRange'_unknownFields = []} + parseMessage + = let + loop :: + DescriptorProto'ExtensionRange + -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ExtensionRange + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "start" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "end" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "ExtensionRange" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData DescriptorProto'ExtensionRange where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_DescriptorProto'ExtensionRange'_unknownFields x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'ExtensionRange'start x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'ExtensionRange'end x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'ExtensionRange'options x__) ()))) +{- | 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'_constructor {_DescriptorProto'ReservedRange'start :: !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ReservedRange'end :: !(Prelude.Maybe Data.Int.Int32), + _DescriptorProto'ReservedRange'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show DescriptorProto'ReservedRange where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "start" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ReservedRange'start + (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'start = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ReservedRange'start + (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'start = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "end" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ReservedRange'end + (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _DescriptorProto'ReservedRange'end + (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'end = y__})) + Prelude.id +instance Data.ProtoLens.Message DescriptorProto'ReservedRange where + messageName _ + = Data.Text.pack "google.protobuf.DescriptorProto.ReservedRange" + packedMessageDescriptor _ + = "\n\ + \\rReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + start__field_descriptor + = Data.ProtoLens.FieldDescriptor + "start" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = DescriptorProto'ReservedRange'_constructor + {_DescriptorProto'ReservedRange'start = Prelude.Nothing, + _DescriptorProto'ReservedRange'end = Prelude.Nothing, + _DescriptorProto'ReservedRange'_unknownFields = []} + parseMessage + = let + loop :: + DescriptorProto'ReservedRange + -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ReservedRange + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "start" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "end" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "ReservedRange" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData DescriptorProto'ReservedRange where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_DescriptorProto'ReservedRange'_unknownFields x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'ReservedRange'start x__) + (Control.DeepSeq.deepseq + (_DescriptorProto'ReservedRange'end x__) ())) +data Edition + = EDITION_UNKNOWN | + EDITION_1_TEST_ONLY | + EDITION_2_TEST_ONLY | + EDITION_LEGACY | + EDITION_PROTO2 | + EDITION_PROTO3 | + EDITION_2023 | + EDITION_2024 | + EDITION_99997_TEST_ONLY | + EDITION_99998_TEST_ONLY | + EDITION_99999_TEST_ONLY | + EDITION_MAX + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum Edition where + maybeToEnum 0 = Prelude.Just EDITION_UNKNOWN + maybeToEnum 1 = Prelude.Just EDITION_1_TEST_ONLY + maybeToEnum 2 = Prelude.Just EDITION_2_TEST_ONLY + maybeToEnum 900 = Prelude.Just EDITION_LEGACY + maybeToEnum 998 = Prelude.Just EDITION_PROTO2 + maybeToEnum 999 = Prelude.Just EDITION_PROTO3 + maybeToEnum 1000 = Prelude.Just EDITION_2023 + maybeToEnum 1001 = Prelude.Just EDITION_2024 + maybeToEnum 99997 = Prelude.Just EDITION_99997_TEST_ONLY + maybeToEnum 99998 = Prelude.Just EDITION_99998_TEST_ONLY + maybeToEnum 99999 = Prelude.Just EDITION_99999_TEST_ONLY + maybeToEnum 2147483647 = Prelude.Just EDITION_MAX + maybeToEnum _ = Prelude.Nothing + showEnum EDITION_UNKNOWN = "EDITION_UNKNOWN" + showEnum EDITION_LEGACY = "EDITION_LEGACY" + showEnum EDITION_PROTO2 = "EDITION_PROTO2" + showEnum EDITION_PROTO3 = "EDITION_PROTO3" + showEnum EDITION_2023 = "EDITION_2023" + showEnum EDITION_2024 = "EDITION_2024" + showEnum EDITION_1_TEST_ONLY = "EDITION_1_TEST_ONLY" + showEnum EDITION_2_TEST_ONLY = "EDITION_2_TEST_ONLY" + showEnum EDITION_99997_TEST_ONLY = "EDITION_99997_TEST_ONLY" + showEnum EDITION_99998_TEST_ONLY = "EDITION_99998_TEST_ONLY" + showEnum EDITION_99999_TEST_ONLY = "EDITION_99999_TEST_ONLY" + showEnum EDITION_MAX = "EDITION_MAX" + readEnum k + | (Prelude.==) k "EDITION_UNKNOWN" = Prelude.Just EDITION_UNKNOWN + | (Prelude.==) k "EDITION_LEGACY" = Prelude.Just EDITION_LEGACY + | (Prelude.==) k "EDITION_PROTO2" = Prelude.Just EDITION_PROTO2 + | (Prelude.==) k "EDITION_PROTO3" = Prelude.Just EDITION_PROTO3 + | (Prelude.==) k "EDITION_2023" = Prelude.Just EDITION_2023 + | (Prelude.==) k "EDITION_2024" = Prelude.Just EDITION_2024 + | (Prelude.==) k "EDITION_1_TEST_ONLY" + = Prelude.Just EDITION_1_TEST_ONLY + | (Prelude.==) k "EDITION_2_TEST_ONLY" + = Prelude.Just EDITION_2_TEST_ONLY + | (Prelude.==) k "EDITION_99997_TEST_ONLY" + = Prelude.Just EDITION_99997_TEST_ONLY + | (Prelude.==) k "EDITION_99998_TEST_ONLY" + = Prelude.Just EDITION_99998_TEST_ONLY + | (Prelude.==) k "EDITION_99999_TEST_ONLY" + = Prelude.Just EDITION_99999_TEST_ONLY + | (Prelude.==) k "EDITION_MAX" = Prelude.Just EDITION_MAX + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded Edition where + minBound = EDITION_UNKNOWN + maxBound = EDITION_MAX +instance Prelude.Enum Edition where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum Edition: " (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum EDITION_UNKNOWN = 0 + fromEnum EDITION_1_TEST_ONLY = 1 + fromEnum EDITION_2_TEST_ONLY = 2 + fromEnum EDITION_LEGACY = 900 + fromEnum EDITION_PROTO2 = 998 + fromEnum EDITION_PROTO3 = 999 + fromEnum EDITION_2023 = 1000 + fromEnum EDITION_2024 = 1001 + fromEnum EDITION_99997_TEST_ONLY = 99997 + fromEnum EDITION_99998_TEST_ONLY = 99998 + fromEnum EDITION_99999_TEST_ONLY = 99999 + fromEnum EDITION_MAX = 2147483647 + succ EDITION_MAX + = Prelude.error + "Edition.succ: bad argument EDITION_MAX. This value would be out of bounds." + succ EDITION_UNKNOWN = EDITION_1_TEST_ONLY + succ EDITION_1_TEST_ONLY = EDITION_2_TEST_ONLY + succ EDITION_2_TEST_ONLY = EDITION_LEGACY + succ EDITION_LEGACY = EDITION_PROTO2 + succ EDITION_PROTO2 = EDITION_PROTO3 + succ EDITION_PROTO3 = EDITION_2023 + succ EDITION_2023 = EDITION_2024 + succ EDITION_2024 = EDITION_99997_TEST_ONLY + succ EDITION_99997_TEST_ONLY = EDITION_99998_TEST_ONLY + succ EDITION_99998_TEST_ONLY = EDITION_99999_TEST_ONLY + succ EDITION_99999_TEST_ONLY = EDITION_MAX + pred EDITION_UNKNOWN + = Prelude.error + "Edition.pred: bad argument EDITION_UNKNOWN. This value would be out of bounds." + pred EDITION_1_TEST_ONLY = EDITION_UNKNOWN + pred EDITION_2_TEST_ONLY = EDITION_1_TEST_ONLY + pred EDITION_LEGACY = EDITION_2_TEST_ONLY + pred EDITION_PROTO2 = EDITION_LEGACY + pred EDITION_PROTO3 = EDITION_PROTO2 + pred EDITION_2023 = EDITION_PROTO3 + pred EDITION_2024 = EDITION_2023 + pred EDITION_99997_TEST_ONLY = EDITION_2024 + pred EDITION_99998_TEST_ONLY = EDITION_99997_TEST_ONLY + pred EDITION_99999_TEST_ONLY = EDITION_99998_TEST_ONLY + pred EDITION_MAX = EDITION_99999_TEST_ONLY + 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 Data.ProtoLens.FieldDefault Edition where + fieldDefault = EDITION_UNKNOWN +instance Control.DeepSeq.NFData Edition where + rnf x__ = Prelude.seq x__ () +{- | 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.vec'value' @:: Lens' EnumDescriptorProto (Data.Vector.Vector EnumValueDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumDescriptorProto EnumOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumDescriptorProto (Prelude.Maybe EnumOptions)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' EnumDescriptorProto [EnumDescriptorProto'EnumReservedRange]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedRange' @:: Lens' EnumDescriptorProto (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' EnumDescriptorProto [Data.Text.Text]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' EnumDescriptorProto (Data.Vector.Vector Data.Text.Text)@ -} +data EnumDescriptorProto + = EnumDescriptorProto'_constructor {_EnumDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text), + _EnumDescriptorProto'value :: !(Data.Vector.Vector EnumValueDescriptorProto), + _EnumDescriptorProto'options :: !(Prelude.Maybe EnumOptions), + _EnumDescriptorProto'reservedRange :: !(Data.Vector.Vector EnumDescriptorProto'EnumReservedRange), + _EnumDescriptorProto'reservedName :: !(Data.Vector.Vector Data.Text.Text), + _EnumDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show EnumDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'name + (\ x__ y__ -> x__ {_EnumDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'name + (\ x__ y__ -> x__ {_EnumDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "value" [EnumValueDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'value + (\ x__ y__ -> x__ {_EnumDescriptorProto'value = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'value" (Data.Vector.Vector EnumValueDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'value + (\ x__ y__ -> x__ {_EnumDescriptorProto'value = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "options" EnumOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'options + (\ x__ y__ -> x__ {_EnumDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "maybe'options" (Prelude.Maybe EnumOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'options + (\ x__ y__ -> x__ {_EnumDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "reservedRange" [EnumDescriptorProto'EnumReservedRange] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'reservedRange + (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedRange = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'reservedRange" (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'reservedRange + (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedRange = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "reservedName" [Data.Text.Text] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'reservedName + (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedName = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'reservedName" (Data.Vector.Vector Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'reservedName + (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedName = y__})) + Prelude.id +instance Data.ProtoLens.Message EnumDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.EnumDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\DC3EnumDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2?\n\ + \\ENQvalue\CAN\STX \ETX(\v2).google.protobuf.EnumValueDescriptorProtoR\ENQvalue\DC26\n\ + \\aoptions\CAN\ETX \SOH(\v2\FS.google.protobuf.EnumOptionsR\aoptions\DC2]\n\ + \\SOreserved_range\CAN\EOT \ETX(\v26.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\DC2#\n\ + \\rreserved_name\CAN\ENQ \ETX(\tR\freservedName\SUB;\n\ + \\DC1EnumReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'options")) :: + Data.ProtoLens.FieldDescriptor EnumDescriptorProto + reservedRange__field_descriptor + = Data.ProtoLens.FieldDescriptor + "reserved_range" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto'EnumReservedRange) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"reservedRange")) :: + Data.ProtoLens.FieldDescriptor EnumDescriptorProto + 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 + (Data.ProtoLens.Field.field @"reservedName")) :: + 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), + (Data.ProtoLens.Tag 4, reservedRange__field_descriptor), + (Data.ProtoLens.Tag 5, reservedName__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _EnumDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_EnumDescriptorProto'_unknownFields = y__}) + defMessage + = EnumDescriptorProto'_constructor + {_EnumDescriptorProto'name = Prelude.Nothing, + _EnumDescriptorProto'value = Data.Vector.Generic.empty, + _EnumDescriptorProto'options = Prelude.Nothing, + _EnumDescriptorProto'reservedRange = Data.Vector.Generic.empty, + _EnumDescriptorProto'reservedName = Data.Vector.Generic.empty, + _EnumDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + EnumDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto'EnumReservedRange + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumValueDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser EnumDescriptorProto + loop x mutable'reservedName mutable'reservedRange mutable'value + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'reservedName) + frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'reservedRange) + frozen'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'value) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'reservedName") + frozen'reservedName + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'reservedRange") + frozen'reservedRange + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'value") frozen'value x)))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + mutable'reservedName + mutable'reservedRange + mutable'value + 18 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "value" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'value y) + loop x mutable'reservedName mutable'reservedRange v + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + mutable'reservedName + mutable'reservedRange + mutable'value + 34 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "reserved_range" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'reservedRange y) + loop x mutable'reservedName v mutable'value + 42 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "reserved_name" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'reservedName y) + loop x v mutable'reservedRange mutable'value + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'reservedName + mutable'reservedRange + mutable'value + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'reservedName + mutable'reservedRange + mutable'value) + "EnumDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'value") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'reservedRange") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 42) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'reservedName") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData EnumDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_EnumDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'value x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'options x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'reservedRange x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'reservedName x__) ()))))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' EnumDescriptorProto'EnumReservedRange (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' EnumDescriptorProto'EnumReservedRange (Prelude.Maybe Data.Int.Int32)@ -} +data EnumDescriptorProto'EnumReservedRange + = EnumDescriptorProto'EnumReservedRange'_constructor {_EnumDescriptorProto'EnumReservedRange'start :: !(Prelude.Maybe Data.Int.Int32), + _EnumDescriptorProto'EnumReservedRange'end :: !(Prelude.Maybe Data.Int.Int32), + _EnumDescriptorProto'EnumReservedRange'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show EnumDescriptorProto'EnumReservedRange where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "start" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'EnumReservedRange'start + (\ x__ y__ + -> x__ {_EnumDescriptorProto'EnumReservedRange'start = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'EnumReservedRange'start + (\ x__ y__ + -> x__ {_EnumDescriptorProto'EnumReservedRange'start = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "end" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'EnumReservedRange'end + (\ x__ y__ + -> x__ {_EnumDescriptorProto'EnumReservedRange'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumDescriptorProto'EnumReservedRange'end + (\ x__ y__ + -> x__ {_EnumDescriptorProto'EnumReservedRange'end = y__})) + Prelude.id +instance Data.ProtoLens.Message EnumDescriptorProto'EnumReservedRange where + messageName _ + = Data.Text.pack + "google.protobuf.EnumDescriptorProto.EnumReservedRange" + packedMessageDescriptor _ + = "\n\ + \\DC1EnumReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + start__field_descriptor + = Data.ProtoLens.FieldDescriptor + "start" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'start")) :: + Data.ProtoLens.FieldDescriptor EnumDescriptorProto'EnumReservedRange + end__field_descriptor + = Data.ProtoLens.FieldDescriptor + "end" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'end")) :: + Data.ProtoLens.FieldDescriptor EnumDescriptorProto'EnumReservedRange + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, start__field_descriptor), + (Data.ProtoLens.Tag 2, end__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _EnumDescriptorProto'EnumReservedRange'_unknownFields + (\ x__ y__ + -> x__ + {_EnumDescriptorProto'EnumReservedRange'_unknownFields = y__}) + defMessage + = EnumDescriptorProto'EnumReservedRange'_constructor + {_EnumDescriptorProto'EnumReservedRange'start = Prelude.Nothing, + _EnumDescriptorProto'EnumReservedRange'end = Prelude.Nothing, + _EnumDescriptorProto'EnumReservedRange'_unknownFields = []} + parseMessage + = let + loop :: + EnumDescriptorProto'EnumReservedRange + -> Data.ProtoLens.Encoding.Bytes.Parser EnumDescriptorProto'EnumReservedRange + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "start" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "end" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "EnumReservedRange" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData EnumDescriptorProto'EnumReservedRange where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_EnumDescriptorProto'EnumReservedRange'_unknownFields x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'EnumReservedRange'start x__) + (Control.DeepSeq.deepseq + (_EnumDescriptorProto'EnumReservedRange'end x__) ())) +{- | 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.deprecatedLegacyJsonFieldConflicts' @:: Lens' EnumOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecatedLegacyJsonFieldConflicts' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' EnumOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' EnumOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumOptions (Data.Vector.Vector UninterpretedOption)@ -} +data EnumOptions + = EnumOptions'_constructor {_EnumOptions'allowAlias :: !(Prelude.Maybe Prelude.Bool), + _EnumOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _EnumOptions'deprecatedLegacyJsonFieldConflicts :: !(Prelude.Maybe Prelude.Bool), + _EnumOptions'features :: !(Prelude.Maybe FeatureSet), + _EnumOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show EnumOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField EnumOptions "allowAlias" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'allowAlias + (\ x__ y__ -> x__ {_EnumOptions'allowAlias = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumOptions "maybe'allowAlias" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'allowAlias + (\ x__ y__ -> x__ {_EnumOptions'allowAlias = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'deprecated + (\ x__ y__ -> x__ {_EnumOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField EnumOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'deprecated + (\ x__ y__ -> x__ {_EnumOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumOptions "deprecatedLegacyJsonFieldConflicts" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'deprecatedLegacyJsonFieldConflicts + (\ x__ y__ + -> x__ {_EnumOptions'deprecatedLegacyJsonFieldConflicts = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumOptions "maybe'deprecatedLegacyJsonFieldConflicts" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'deprecatedLegacyJsonFieldConflicts + (\ x__ y__ + -> x__ {_EnumOptions'deprecatedLegacyJsonFieldConflicts = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'features + (\ x__ y__ -> x__ {_EnumOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField EnumOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'features + (\ x__ y__ -> x__ {_EnumOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'uninterpretedOption + (\ x__ y__ -> x__ {_EnumOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField EnumOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumOptions'uninterpretedOption + (\ x__ y__ -> x__ {_EnumOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message EnumOptions where + messageName _ = Data.Text.pack "google.protobuf.EnumOptions" + packedMessageDescriptor _ + = "\n\ + \\vEnumOptions\DC2\US\n\ + \\vallow_alias\CAN\STX \SOH(\bR\n\ + \allowAlias\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2V\n\ + \&deprecated_legacy_json_field_conflicts\CAN\ACK \SOH(\bR\"deprecatedLegacyJsonFieldConflictsB\STX\CAN\SOH\DC27\n\ + \\bfeatures\CAN\a \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\ENQ\DLE\ACK" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + allowAlias__field_descriptor + = Data.ProtoLens.FieldDescriptor + "allow_alias" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'deprecated")) :: + Data.ProtoLens.FieldDescriptor EnumOptions + deprecatedLegacyJsonFieldConflicts__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecated_legacy_json_field_conflicts" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field + @"maybe'deprecatedLegacyJsonFieldConflicts")) :: + Data.ProtoLens.FieldDescriptor EnumOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + 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 + (Data.ProtoLens.Field.field @"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 6, + deprecatedLegacyJsonFieldConflicts__field_descriptor), + (Data.ProtoLens.Tag 7, features__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _EnumOptions'_unknownFields + (\ x__ y__ -> x__ {_EnumOptions'_unknownFields = y__}) + defMessage + = EnumOptions'_constructor + {_EnumOptions'allowAlias = Prelude.Nothing, + _EnumOptions'deprecated = Prelude.Nothing, + _EnumOptions'deprecatedLegacyJsonFieldConflicts = Prelude.Nothing, + _EnumOptions'features = Prelude.Nothing, + _EnumOptions'uninterpretedOption = Data.Vector.Generic.empty, + _EnumOptions'_unknownFields = []} + parseMessage + = let + loop :: + EnumOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser EnumOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "allow_alias" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"allowAlias") y x) + mutable'uninterpretedOption + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 48 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated_legacy_json_field_conflicts" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field + @"deprecatedLegacyJsonFieldConflicts") + y + x) + mutable'uninterpretedOption + 58 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "EnumOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'allowAlias") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'deprecatedLegacyJsonFieldConflicts") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 48) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 58) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData EnumOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_EnumOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_EnumOptions'allowAlias x__) + (Control.DeepSeq.deepseq + (_EnumOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_EnumOptions'deprecatedLegacyJsonFieldConflicts x__) + (Control.DeepSeq.deepseq + (_EnumOptions'features x__) + (Control.DeepSeq.deepseq + (_EnumOptions'uninterpretedOption x__) ()))))) +{- | 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'_constructor {_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 stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show EnumValueDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'name + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'name + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "number" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'number + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'number = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'number" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'number + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'number = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "options" EnumValueOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'options + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'options" (Prelude.Maybe EnumValueOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueDescriptorProto'options + (\ x__ y__ -> x__ {_EnumValueDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Message EnumValueDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.EnumValueDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\CANEnumValueDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\SYN\n\ + \\ACKnumber\CAN\STX \SOH(\ENQR\ACKnumber\DC2;\n\ + \\aoptions\CAN\ETX \SOH(\v2!.google.protobuf.EnumValueOptionsR\aoptions" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = EnumValueDescriptorProto'_constructor + {_EnumValueDescriptorProto'name = Prelude.Nothing, + _EnumValueDescriptorProto'number = Prelude.Nothing, + _EnumValueDescriptorProto'options = Prelude.Nothing, + _EnumValueDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + EnumValueDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser EnumValueDescriptorProto + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "number" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"number") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "EnumValueDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData EnumValueDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_EnumValueDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_EnumValueDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_EnumValueDescriptorProto'number x__) + (Control.DeepSeq.deepseq + (_EnumValueDescriptorProto'options x__) ()))) +{- | 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.features' @:: Lens' EnumValueOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' EnumValueOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.debugRedact' @:: Lens' EnumValueOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'debugRedact' @:: Lens' EnumValueOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.featureSupport' @:: Lens' EnumValueOptions FieldOptions'FeatureSupport@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'featureSupport' @:: Lens' EnumValueOptions (Prelude.Maybe FieldOptions'FeatureSupport)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumValueOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumValueOptions (Data.Vector.Vector UninterpretedOption)@ -} +data EnumValueOptions + = EnumValueOptions'_constructor {_EnumValueOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _EnumValueOptions'features :: !(Prelude.Maybe FeatureSet), + _EnumValueOptions'debugRedact :: !(Prelude.Maybe Prelude.Bool), + _EnumValueOptions'featureSupport :: !(Prelude.Maybe FieldOptions'FeatureSupport), + _EnumValueOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _EnumValueOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show EnumValueOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField EnumValueOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'deprecated + (\ x__ y__ -> x__ {_EnumValueOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField EnumValueOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'deprecated + (\ x__ y__ -> x__ {_EnumValueOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'features + (\ x__ y__ -> x__ {_EnumValueOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField EnumValueOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'features + (\ x__ y__ -> x__ {_EnumValueOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueOptions "debugRedact" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'debugRedact + (\ x__ y__ -> x__ {_EnumValueOptions'debugRedact = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField EnumValueOptions "maybe'debugRedact" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'debugRedact + (\ x__ y__ -> x__ {_EnumValueOptions'debugRedact = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueOptions "featureSupport" FieldOptions'FeatureSupport where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'featureSupport + (\ x__ y__ -> x__ {_EnumValueOptions'featureSupport = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField EnumValueOptions "maybe'featureSupport" (Prelude.Maybe FieldOptions'FeatureSupport) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'featureSupport + (\ x__ y__ -> x__ {_EnumValueOptions'featureSupport = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField EnumValueOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'uninterpretedOption + (\ x__ y__ -> x__ {_EnumValueOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField EnumValueOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _EnumValueOptions'uninterpretedOption + (\ x__ y__ -> x__ {_EnumValueOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message EnumValueOptions where + messageName _ = Data.Text.pack "google.protobuf.EnumValueOptions" + packedMessageDescriptor _ + = "\n\ + \\DLEEnumValueOptions\DC2%\n\ + \\n\ + \deprecated\CAN\SOH \SOH(\b:\ENQfalseR\n\ + \deprecated\DC27\n\ + \\bfeatures\CAN\STX \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2(\n\ + \\fdebug_redact\CAN\ETX \SOH(\b:\ENQfalseR\vdebugRedact\DC2U\n\ + \\SIfeature_support\CAN\EOT \SOH(\v2,.google.protobuf.FieldOptions.FeatureSupportR\SOfeatureSupport\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'deprecated")) :: + Data.ProtoLens.FieldDescriptor EnumValueOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + Data.ProtoLens.FieldDescriptor EnumValueOptions + debugRedact__field_descriptor + = Data.ProtoLens.FieldDescriptor + "debug_redact" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'debugRedact")) :: + Data.ProtoLens.FieldDescriptor EnumValueOptions + featureSupport__field_descriptor + = Data.ProtoLens.FieldDescriptor + "feature_support" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'FeatureSupport) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'featureSupport")) :: + 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 + (Data.ProtoLens.Field.field @"uninterpretedOption")) :: + Data.ProtoLens.FieldDescriptor EnumValueOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, deprecated__field_descriptor), + (Data.ProtoLens.Tag 2, features__field_descriptor), + (Data.ProtoLens.Tag 3, debugRedact__field_descriptor), + (Data.ProtoLens.Tag 4, featureSupport__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _EnumValueOptions'_unknownFields + (\ x__ y__ -> x__ {_EnumValueOptions'_unknownFields = y__}) + defMessage + = EnumValueOptions'_constructor + {_EnumValueOptions'deprecated = Prelude.Nothing, + _EnumValueOptions'features = Prelude.Nothing, + _EnumValueOptions'debugRedact = Prelude.Nothing, + _EnumValueOptions'featureSupport = Prelude.Nothing, + _EnumValueOptions'uninterpretedOption = Data.Vector.Generic.empty, + _EnumValueOptions'_unknownFields = []} + parseMessage + = let + loop :: + EnumValueOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser EnumValueOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "debug_redact" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"debugRedact") y x) + mutable'uninterpretedOption + 34 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "feature_support" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"featureSupport") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "EnumValueOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'debugRedact") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'featureSupport") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData EnumValueOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_EnumValueOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_EnumValueOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_EnumValueOptions'features x__) + (Control.DeepSeq.deepseq + (_EnumValueOptions'debugRedact x__) + (Control.DeepSeq.deepseq + (_EnumValueOptions'featureSupport x__) + (Control.DeepSeq.deepseq + (_EnumValueOptions'uninterpretedOption x__) ()))))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ExtensionRangeOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' ExtensionRangeOptions (Data.Vector.Vector UninterpretedOption)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.declaration' @:: Lens' ExtensionRangeOptions [ExtensionRangeOptions'Declaration]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'declaration' @:: Lens' ExtensionRangeOptions (Data.Vector.Vector ExtensionRangeOptions'Declaration)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' ExtensionRangeOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' ExtensionRangeOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.verification' @:: Lens' ExtensionRangeOptions ExtensionRangeOptions'VerificationState@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'verification' @:: Lens' ExtensionRangeOptions (Prelude.Maybe ExtensionRangeOptions'VerificationState)@ -} +data ExtensionRangeOptions + = ExtensionRangeOptions'_constructor {_ExtensionRangeOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _ExtensionRangeOptions'declaration :: !(Data.Vector.Vector ExtensionRangeOptions'Declaration), + _ExtensionRangeOptions'features :: !(Prelude.Maybe FeatureSet), + _ExtensionRangeOptions'verification :: !(Prelude.Maybe ExtensionRangeOptions'VerificationState), + _ExtensionRangeOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show ExtensionRangeOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'uninterpretedOption + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'uninterpretedOption + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "declaration" [ExtensionRangeOptions'Declaration] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'declaration + (\ x__ y__ -> x__ {_ExtensionRangeOptions'declaration = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "vec'declaration" (Data.Vector.Vector ExtensionRangeOptions'Declaration) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'declaration + (\ x__ y__ -> x__ {_ExtensionRangeOptions'declaration = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'features + (\ x__ y__ -> x__ {_ExtensionRangeOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'features + (\ x__ y__ -> x__ {_ExtensionRangeOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "verification" ExtensionRangeOptions'VerificationState where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'verification + (\ x__ y__ -> x__ {_ExtensionRangeOptions'verification = y__})) + (Data.ProtoLens.maybeLens ExtensionRangeOptions'UNVERIFIED) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "maybe'verification" (Prelude.Maybe ExtensionRangeOptions'VerificationState) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'verification + (\ x__ y__ -> x__ {_ExtensionRangeOptions'verification = y__})) + Prelude.id +instance Data.ProtoLens.Message ExtensionRangeOptions where + messageName _ + = Data.Text.pack "google.protobuf.ExtensionRangeOptions" + packedMessageDescriptor _ + = "\n\ + \\NAKExtensionRangeOptions\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\DC2Y\n\ + \\vdeclaration\CAN\STX \ETX(\v22.google.protobuf.ExtensionRangeOptions.DeclarationR\vdeclarationB\ETX\136\SOH\STX\DC27\n\ + \\bfeatures\CAN2 \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2m\n\ + \\fverification\CAN\ETX \SOH(\SO28.google.protobuf.ExtensionRangeOptions.VerificationState:\n\ + \UNVERIFIEDR\fverificationB\ETX\136\SOH\STX\SUB\148\SOH\n\ + \\vDeclaration\DC2\SYN\n\ + \\ACKnumber\CAN\SOH \SOH(\ENQR\ACKnumber\DC2\ESC\n\ + \\tfull_name\CAN\STX \SOH(\tR\bfullName\DC2\DC2\n\ + \\EOTtype\CAN\ETX \SOH(\tR\EOTtype\DC2\SUB\n\ + \\breserved\CAN\ENQ \SOH(\bR\breserved\DC2\SUB\n\ + \\brepeated\CAN\ACK \SOH(\bR\brepeatedJ\EOT\b\EOT\DLE\ENQ\"4\n\ + \\DC1VerificationState\DC2\SI\n\ + \\vDECLARATION\DLE\NUL\DC2\SO\n\ + \\n\ + \UNVERIFIED\DLE\SOH*\t\b\232\a\DLE\128\128\128\128\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor + "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"uninterpretedOption")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions + declaration__field_descriptor + = Data.ProtoLens.FieldDescriptor + "declaration" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor ExtensionRangeOptions'Declaration) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"declaration")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions + verification__field_descriptor + = Data.ProtoLens.FieldDescriptor + "verification" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor ExtensionRangeOptions'VerificationState) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'verification")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor), + (Data.ProtoLens.Tag 2, declaration__field_descriptor), + (Data.ProtoLens.Tag 50, features__field_descriptor), + (Data.ProtoLens.Tag 3, verification__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'_unknownFields + (\ x__ y__ -> x__ {_ExtensionRangeOptions'_unknownFields = y__}) + defMessage + = ExtensionRangeOptions'_constructor + {_ExtensionRangeOptions'uninterpretedOption = Data.Vector.Generic.empty, + _ExtensionRangeOptions'declaration = Data.Vector.Generic.empty, + _ExtensionRangeOptions'features = Prelude.Nothing, + _ExtensionRangeOptions'verification = Prelude.Nothing, + _ExtensionRangeOptions'_unknownFields = []} + parseMessage + = let + loop :: + ExtensionRangeOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld ExtensionRangeOptions'Declaration + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser ExtensionRangeOptions + loop x mutable'declaration mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'declaration <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'declaration) + frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'declaration") + frozen'declaration + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x mutable'declaration v + 18 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "declaration" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'declaration y) + loop x v mutable'uninterpretedOption + 402 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'declaration + mutable'uninterpretedOption + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "verification" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"verification") y x) + mutable'declaration + mutable'uninterpretedOption + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'declaration + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'declaration <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'declaration + mutable'uninterpretedOption) + "ExtensionRangeOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'declaration") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 402) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'verification") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))) +instance Control.DeepSeq.NFData ExtensionRangeOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_ExtensionRangeOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'uninterpretedOption x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'declaration x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'features x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'verification x__) ())))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' ExtensionRangeOptions'Declaration Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' ExtensionRangeOptions'Declaration (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.fullName' @:: Lens' ExtensionRangeOptions'Declaration Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'fullName' @:: Lens' ExtensionRangeOptions'Declaration (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' ExtensionRangeOptions'Declaration Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' ExtensionRangeOptions'Declaration (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.reserved' @:: Lens' ExtensionRangeOptions'Declaration Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'reserved' @:: Lens' ExtensionRangeOptions'Declaration (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.repeated' @:: Lens' ExtensionRangeOptions'Declaration Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'repeated' @:: Lens' ExtensionRangeOptions'Declaration (Prelude.Maybe Prelude.Bool)@ -} +data ExtensionRangeOptions'Declaration + = ExtensionRangeOptions'Declaration'_constructor {_ExtensionRangeOptions'Declaration'number :: !(Prelude.Maybe Data.Int.Int32), + _ExtensionRangeOptions'Declaration'fullName :: !(Prelude.Maybe Data.Text.Text), + _ExtensionRangeOptions'Declaration'type' :: !(Prelude.Maybe Data.Text.Text), + _ExtensionRangeOptions'Declaration'reserved :: !(Prelude.Maybe Prelude.Bool), + _ExtensionRangeOptions'Declaration'repeated :: !(Prelude.Maybe Prelude.Bool), + _ExtensionRangeOptions'Declaration'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show ExtensionRangeOptions'Declaration where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "number" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'number + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'number = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "maybe'number" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'number + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'number = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "fullName" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'fullName + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'fullName = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "maybe'fullName" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'fullName + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'fullName = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "type'" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'type' + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'type' = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "maybe'type'" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'type' + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'type' = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "reserved" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'reserved + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'reserved = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "maybe'reserved" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'reserved + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'reserved = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "repeated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'repeated + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'repeated = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ExtensionRangeOptions'Declaration "maybe'repeated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'repeated + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'repeated = y__})) + Prelude.id +instance Data.ProtoLens.Message ExtensionRangeOptions'Declaration where + messageName _ + = Data.Text.pack + "google.protobuf.ExtensionRangeOptions.Declaration" + packedMessageDescriptor _ + = "\n\ + \\vDeclaration\DC2\SYN\n\ + \\ACKnumber\CAN\SOH \SOH(\ENQR\ACKnumber\DC2\ESC\n\ + \\tfull_name\CAN\STX \SOH(\tR\bfullName\DC2\DC2\n\ + \\EOTtype\CAN\ETX \SOH(\tR\EOTtype\DC2\SUB\n\ + \\breserved\CAN\ENQ \SOH(\bR\breserved\DC2\SUB\n\ + \\brepeated\CAN\ACK \SOH(\bR\brepeatedJ\EOT\b\EOT\DLE\ENQ" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + number__field_descriptor + = Data.ProtoLens.FieldDescriptor + "number" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'number")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions'Declaration + fullName__field_descriptor + = Data.ProtoLens.FieldDescriptor + "full_name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'fullName")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions'Declaration + type'__field_descriptor + = Data.ProtoLens.FieldDescriptor + "type" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'type'")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions'Declaration + reserved__field_descriptor + = Data.ProtoLens.FieldDescriptor + "reserved" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'reserved")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions'Declaration + repeated__field_descriptor + = Data.ProtoLens.FieldDescriptor + "repeated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'repeated")) :: + Data.ProtoLens.FieldDescriptor ExtensionRangeOptions'Declaration + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, number__field_descriptor), + (Data.ProtoLens.Tag 2, fullName__field_descriptor), + (Data.ProtoLens.Tag 3, type'__field_descriptor), + (Data.ProtoLens.Tag 5, reserved__field_descriptor), + (Data.ProtoLens.Tag 6, repeated__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _ExtensionRangeOptions'Declaration'_unknownFields + (\ x__ y__ + -> x__ {_ExtensionRangeOptions'Declaration'_unknownFields = y__}) + defMessage + = ExtensionRangeOptions'Declaration'_constructor + {_ExtensionRangeOptions'Declaration'number = Prelude.Nothing, + _ExtensionRangeOptions'Declaration'fullName = Prelude.Nothing, + _ExtensionRangeOptions'Declaration'type' = Prelude.Nothing, + _ExtensionRangeOptions'Declaration'reserved = Prelude.Nothing, + _ExtensionRangeOptions'Declaration'repeated = Prelude.Nothing, + _ExtensionRangeOptions'Declaration'_unknownFields = []} + parseMessage + = let + loop :: + ExtensionRangeOptions'Declaration + -> Data.ProtoLens.Encoding.Bytes.Parser ExtensionRangeOptions'Declaration + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "number" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"number") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "full_name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"fullName") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "type" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"type'") y x) + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "reserved" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"reserved") y x) + 48 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "repeated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"repeated") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "Declaration" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'fullName") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'type'") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'reserved") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'repeated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 48) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData ExtensionRangeOptions'Declaration where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'_unknownFields x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'number x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'fullName x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'type' x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'reserved x__) + (Control.DeepSeq.deepseq + (_ExtensionRangeOptions'Declaration'repeated x__) ()))))) +data ExtensionRangeOptions'VerificationState + = ExtensionRangeOptions'DECLARATION | + ExtensionRangeOptions'UNVERIFIED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum ExtensionRangeOptions'VerificationState where + maybeToEnum 0 = Prelude.Just ExtensionRangeOptions'DECLARATION + maybeToEnum 1 = Prelude.Just ExtensionRangeOptions'UNVERIFIED + maybeToEnum _ = Prelude.Nothing + showEnum ExtensionRangeOptions'DECLARATION = "DECLARATION" + showEnum ExtensionRangeOptions'UNVERIFIED = "UNVERIFIED" + readEnum k + | (Prelude.==) k "DECLARATION" + = Prelude.Just ExtensionRangeOptions'DECLARATION + | (Prelude.==) k "UNVERIFIED" + = Prelude.Just ExtensionRangeOptions'UNVERIFIED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded ExtensionRangeOptions'VerificationState where + minBound = ExtensionRangeOptions'DECLARATION + maxBound = ExtensionRangeOptions'UNVERIFIED +instance Prelude.Enum ExtensionRangeOptions'VerificationState where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum VerificationState: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum ExtensionRangeOptions'DECLARATION = 0 + fromEnum ExtensionRangeOptions'UNVERIFIED = 1 + succ ExtensionRangeOptions'UNVERIFIED + = Prelude.error + "ExtensionRangeOptions'VerificationState.succ: bad argument ExtensionRangeOptions'UNVERIFIED. This value would be out of bounds." + succ ExtensionRangeOptions'DECLARATION + = ExtensionRangeOptions'UNVERIFIED + pred ExtensionRangeOptions'DECLARATION + = Prelude.error + "ExtensionRangeOptions'VerificationState.pred: bad argument ExtensionRangeOptions'DECLARATION. This value would be out of bounds." + pred ExtensionRangeOptions'UNVERIFIED + = ExtensionRangeOptions'DECLARATION + 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 Data.ProtoLens.FieldDefault ExtensionRangeOptions'VerificationState where + fieldDefault = ExtensionRangeOptions'DECLARATION +instance Control.DeepSeq.NFData ExtensionRangeOptions'VerificationState where + rnf x__ = Prelude.seq x__ () +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.fieldPresence' @:: Lens' FeatureSet FeatureSet'FieldPresence@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'fieldPresence' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'FieldPresence)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' FeatureSet FeatureSet'EnumType@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'enumType' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'EnumType)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.repeatedFieldEncoding' @:: Lens' FeatureSet FeatureSet'RepeatedFieldEncoding@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'repeatedFieldEncoding' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'RepeatedFieldEncoding)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.utf8Validation' @:: Lens' FeatureSet FeatureSet'Utf8Validation@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'utf8Validation' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'Utf8Validation)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.messageEncoding' @:: Lens' FeatureSet FeatureSet'MessageEncoding@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'messageEncoding' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'MessageEncoding)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.jsonFormat' @:: Lens' FeatureSet FeatureSet'JsonFormat@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonFormat' @:: Lens' FeatureSet (Prelude.Maybe FeatureSet'JsonFormat)@ -} +data FeatureSet + = FeatureSet'_constructor {_FeatureSet'fieldPresence :: !(Prelude.Maybe FeatureSet'FieldPresence), + _FeatureSet'enumType :: !(Prelude.Maybe FeatureSet'EnumType), + _FeatureSet'repeatedFieldEncoding :: !(Prelude.Maybe FeatureSet'RepeatedFieldEncoding), + _FeatureSet'utf8Validation :: !(Prelude.Maybe FeatureSet'Utf8Validation), + _FeatureSet'messageEncoding :: !(Prelude.Maybe FeatureSet'MessageEncoding), + _FeatureSet'jsonFormat :: !(Prelude.Maybe FeatureSet'JsonFormat), + _FeatureSet'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FeatureSet where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FeatureSet "fieldPresence" FeatureSet'FieldPresence where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'fieldPresence + (\ x__ y__ -> x__ {_FeatureSet'fieldPresence = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'fieldPresence" (Prelude.Maybe FeatureSet'FieldPresence) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'fieldPresence + (\ x__ y__ -> x__ {_FeatureSet'fieldPresence = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSet "enumType" FeatureSet'EnumType where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'enumType + (\ x__ y__ -> x__ {_FeatureSet'enumType = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'enumType" (Prelude.Maybe FeatureSet'EnumType) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'enumType + (\ x__ y__ -> x__ {_FeatureSet'enumType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSet "repeatedFieldEncoding" FeatureSet'RepeatedFieldEncoding where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'repeatedFieldEncoding + (\ x__ y__ -> x__ {_FeatureSet'repeatedFieldEncoding = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'repeatedFieldEncoding" (Prelude.Maybe FeatureSet'RepeatedFieldEncoding) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'repeatedFieldEncoding + (\ x__ y__ -> x__ {_FeatureSet'repeatedFieldEncoding = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSet "utf8Validation" FeatureSet'Utf8Validation where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'utf8Validation + (\ x__ y__ -> x__ {_FeatureSet'utf8Validation = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'utf8Validation" (Prelude.Maybe FeatureSet'Utf8Validation) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'utf8Validation + (\ x__ y__ -> x__ {_FeatureSet'utf8Validation = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSet "messageEncoding" FeatureSet'MessageEncoding where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'messageEncoding + (\ x__ y__ -> x__ {_FeatureSet'messageEncoding = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'messageEncoding" (Prelude.Maybe FeatureSet'MessageEncoding) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'messageEncoding + (\ x__ y__ -> x__ {_FeatureSet'messageEncoding = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSet "jsonFormat" FeatureSet'JsonFormat where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'jsonFormat + (\ x__ y__ -> x__ {_FeatureSet'jsonFormat = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSet "maybe'jsonFormat" (Prelude.Maybe FeatureSet'JsonFormat) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSet'jsonFormat + (\ x__ y__ -> x__ {_FeatureSet'jsonFormat = y__})) + Prelude.id +instance Data.ProtoLens.Message FeatureSet where + messageName _ = Data.Text.pack "google.protobuf.FeatureSet" + packedMessageDescriptor _ + = "\n\ + \\n\ + \FeatureSet\DC2\145\SOH\n\ + \\SOfield_presence\CAN\SOH \SOH(\SO2).google.protobuf.FeatureSet.FieldPresenceR\rfieldPresenceB?\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\r\DC2\bEXPLICIT\CAN\132\a\162\SOH\r\DC2\bIMPLICIT\CAN\231\a\162\SOH\r\DC2\bEXPLICIT\CAN\232\a\178\SOH\ETX\b\232\a\DC2l\n\ + \\tenum_type\CAN\STX \SOH(\SO2$.google.protobuf.FeatureSet.EnumTypeR\benumTypeB)\136\SOH\SOH\152\SOH\ACK\152\SOH\SOH\162\SOH\v\DC2\ACKCLOSED\CAN\132\a\162\SOH\t\DC2\EOTOPEN\CAN\231\a\178\SOH\ETX\b\232\a\DC2\152\SOH\n\ + \\ETBrepeated_field_encoding\CAN\ETX \SOH(\SO21.google.protobuf.FeatureSet.RepeatedFieldEncodingR\NAKrepeatedFieldEncodingB-\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\r\DC2\bEXPANDED\CAN\132\a\162\SOH\v\DC2\ACKPACKED\CAN\231\a\178\SOH\ETX\b\232\a\DC2~\n\ + \\SIutf8_validation\CAN\EOT \SOH(\SO2*.google.protobuf.FeatureSet.Utf8ValidationR\SOutf8ValidationB)\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\t\DC2\EOTNONE\CAN\132\a\162\SOH\v\DC2\ACKVERIFY\CAN\231\a\178\SOH\ETX\b\232\a\DC2~\n\ + \\DLEmessage_encoding\CAN\ENQ \SOH(\SO2+.google.protobuf.FeatureSet.MessageEncodingR\SImessageEncodingB&\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\DC4\DC2\SILENGTH_PREFIXED\CAN\132\a\178\SOH\ETX\b\232\a\DC2\130\SOH\n\ + \\vjson_format\CAN\ACK \SOH(\SO2&.google.protobuf.FeatureSet.JsonFormatR\n\ + \jsonFormatB9\136\SOH\SOH\152\SOH\ETX\152\SOH\ACK\152\SOH\SOH\162\SOH\ETB\DC2\DC2LEGACY_BEST_EFFORT\CAN\132\a\162\SOH\n\ + \\DC2\ENQALLOW\CAN\231\a\178\SOH\ETX\b\232\a\"\\\n\ + \\rFieldPresence\DC2\SUB\n\ + \\SYNFIELD_PRESENCE_UNKNOWN\DLE\NUL\DC2\f\n\ + \\bEXPLICIT\DLE\SOH\DC2\f\n\ + \\bIMPLICIT\DLE\STX\DC2\DC3\n\ + \\SILEGACY_REQUIRED\DLE\ETX\"7\n\ + \\bEnumType\DC2\NAK\n\ + \\DC1ENUM_TYPE_UNKNOWN\DLE\NUL\DC2\b\n\ + \\EOTOPEN\DLE\SOH\DC2\n\ + \\n\ + \\ACKCLOSED\DLE\STX\"V\n\ + \\NAKRepeatedFieldEncoding\DC2#\n\ + \\USREPEATED_FIELD_ENCODING_UNKNOWN\DLE\NUL\DC2\n\ + \\n\ + \\ACKPACKED\DLE\SOH\DC2\f\n\ + \\bEXPANDED\DLE\STX\"I\n\ + \\SOUtf8Validation\DC2\ESC\n\ + \\ETBUTF8_VALIDATION_UNKNOWN\DLE\NUL\DC2\n\ + \\n\ + \\ACKVERIFY\DLE\STX\DC2\b\n\ + \\EOTNONE\DLE\ETX\"\EOT\b\SOH\DLE\SOH\"S\n\ + \\SIMessageEncoding\DC2\FS\n\ + \\CANMESSAGE_ENCODING_UNKNOWN\DLE\NUL\DC2\DC3\n\ + \\SILENGTH_PREFIXED\DLE\SOH\DC2\r\n\ + \\tDELIMITED\DLE\STX\"H\n\ + \\n\ + \JsonFormat\DC2\ETB\n\ + \\DC3JSON_FORMAT_UNKNOWN\DLE\NUL\DC2\t\n\ + \\ENQALLOW\DLE\SOH\DC2\SYN\n\ + \\DC2LEGACY_BEST_EFFORT\DLE\STX*\ACK\b\232\a\DLE\139N*\ACK\b\139N\DLE\144N*\ACK\b\144N\DLE\145NJ\ACK\b\231\a\DLE\232\a" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + fieldPresence__field_descriptor + = Data.ProtoLens.FieldDescriptor + "field_presence" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'FieldPresence) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'fieldPresence")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + enumType__field_descriptor + = Data.ProtoLens.FieldDescriptor + "enum_type" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'EnumType) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'enumType")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + repeatedFieldEncoding__field_descriptor + = Data.ProtoLens.FieldDescriptor + "repeated_field_encoding" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'RepeatedFieldEncoding) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'repeatedFieldEncoding")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + utf8Validation__field_descriptor + = Data.ProtoLens.FieldDescriptor + "utf8_validation" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'Utf8Validation) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'utf8Validation")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + messageEncoding__field_descriptor + = Data.ProtoLens.FieldDescriptor + "message_encoding" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'MessageEncoding) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'messageEncoding")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + jsonFormat__field_descriptor + = Data.ProtoLens.FieldDescriptor + "json_format" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet'JsonFormat) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'jsonFormat")) :: + Data.ProtoLens.FieldDescriptor FeatureSet + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, fieldPresence__field_descriptor), + (Data.ProtoLens.Tag 2, enumType__field_descriptor), + (Data.ProtoLens.Tag 3, repeatedFieldEncoding__field_descriptor), + (Data.ProtoLens.Tag 4, utf8Validation__field_descriptor), + (Data.ProtoLens.Tag 5, messageEncoding__field_descriptor), + (Data.ProtoLens.Tag 6, jsonFormat__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FeatureSet'_unknownFields + (\ x__ y__ -> x__ {_FeatureSet'_unknownFields = y__}) + defMessage + = FeatureSet'_constructor + {_FeatureSet'fieldPresence = Prelude.Nothing, + _FeatureSet'enumType = Prelude.Nothing, + _FeatureSet'repeatedFieldEncoding = Prelude.Nothing, + _FeatureSet'utf8Validation = Prelude.Nothing, + _FeatureSet'messageEncoding = Prelude.Nothing, + _FeatureSet'jsonFormat = Prelude.Nothing, + _FeatureSet'_unknownFields = []} + parseMessage + = let + loop :: + FeatureSet -> Data.ProtoLens.Encoding.Bytes.Parser FeatureSet + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "field_presence" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"fieldPresence") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "enum_type" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"enumType") y x) + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "repeated_field_encoding" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"repeatedFieldEncoding") y x) + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "utf8_validation" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"utf8Validation") y x) + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "message_encoding" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"messageEncoding") y x) + 48 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "json_format" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"jsonFormat") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "FeatureSet" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'fieldPresence") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'enumType") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'repeatedFieldEncoding") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'utf8Validation") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'messageEncoding") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'jsonFormat") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 48) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))) +instance Control.DeepSeq.NFData FeatureSet where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FeatureSet'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FeatureSet'fieldPresence x__) + (Control.DeepSeq.deepseq + (_FeatureSet'enumType x__) + (Control.DeepSeq.deepseq + (_FeatureSet'repeatedFieldEncoding x__) + (Control.DeepSeq.deepseq + (_FeatureSet'utf8Validation x__) + (Control.DeepSeq.deepseq + (_FeatureSet'messageEncoding x__) + (Control.DeepSeq.deepseq (_FeatureSet'jsonFormat x__) ())))))) +data FeatureSet'EnumType + = FeatureSet'ENUM_TYPE_UNKNOWN | + FeatureSet'OPEN | + FeatureSet'CLOSED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'EnumType where + maybeToEnum 0 = Prelude.Just FeatureSet'ENUM_TYPE_UNKNOWN + maybeToEnum 1 = Prelude.Just FeatureSet'OPEN + maybeToEnum 2 = Prelude.Just FeatureSet'CLOSED + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'ENUM_TYPE_UNKNOWN = "ENUM_TYPE_UNKNOWN" + showEnum FeatureSet'OPEN = "OPEN" + showEnum FeatureSet'CLOSED = "CLOSED" + readEnum k + | (Prelude.==) k "ENUM_TYPE_UNKNOWN" + = Prelude.Just FeatureSet'ENUM_TYPE_UNKNOWN + | (Prelude.==) k "OPEN" = Prelude.Just FeatureSet'OPEN + | (Prelude.==) k "CLOSED" = Prelude.Just FeatureSet'CLOSED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'EnumType where + minBound = FeatureSet'ENUM_TYPE_UNKNOWN + maxBound = FeatureSet'CLOSED +instance Prelude.Enum FeatureSet'EnumType where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum EnumType: " (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'ENUM_TYPE_UNKNOWN = 0 + fromEnum FeatureSet'OPEN = 1 + fromEnum FeatureSet'CLOSED = 2 + succ FeatureSet'CLOSED + = Prelude.error + "FeatureSet'EnumType.succ: bad argument FeatureSet'CLOSED. This value would be out of bounds." + succ FeatureSet'ENUM_TYPE_UNKNOWN = FeatureSet'OPEN + succ FeatureSet'OPEN = FeatureSet'CLOSED + pred FeatureSet'ENUM_TYPE_UNKNOWN + = Prelude.error + "FeatureSet'EnumType.pred: bad argument FeatureSet'ENUM_TYPE_UNKNOWN. This value would be out of bounds." + pred FeatureSet'OPEN = FeatureSet'ENUM_TYPE_UNKNOWN + pred FeatureSet'CLOSED = FeatureSet'OPEN + 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 Data.ProtoLens.FieldDefault FeatureSet'EnumType where + fieldDefault = FeatureSet'ENUM_TYPE_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'EnumType where + rnf x__ = Prelude.seq x__ () +data FeatureSet'FieldPresence + = FeatureSet'FIELD_PRESENCE_UNKNOWN | + FeatureSet'EXPLICIT | + FeatureSet'IMPLICIT | + FeatureSet'LEGACY_REQUIRED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'FieldPresence where + maybeToEnum 0 = Prelude.Just FeatureSet'FIELD_PRESENCE_UNKNOWN + maybeToEnum 1 = Prelude.Just FeatureSet'EXPLICIT + maybeToEnum 2 = Prelude.Just FeatureSet'IMPLICIT + maybeToEnum 3 = Prelude.Just FeatureSet'LEGACY_REQUIRED + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'FIELD_PRESENCE_UNKNOWN + = "FIELD_PRESENCE_UNKNOWN" + showEnum FeatureSet'EXPLICIT = "EXPLICIT" + showEnum FeatureSet'IMPLICIT = "IMPLICIT" + showEnum FeatureSet'LEGACY_REQUIRED = "LEGACY_REQUIRED" + readEnum k + | (Prelude.==) k "FIELD_PRESENCE_UNKNOWN" + = Prelude.Just FeatureSet'FIELD_PRESENCE_UNKNOWN + | (Prelude.==) k "EXPLICIT" = Prelude.Just FeatureSet'EXPLICIT + | (Prelude.==) k "IMPLICIT" = Prelude.Just FeatureSet'IMPLICIT + | (Prelude.==) k "LEGACY_REQUIRED" + = Prelude.Just FeatureSet'LEGACY_REQUIRED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'FieldPresence where + minBound = FeatureSet'FIELD_PRESENCE_UNKNOWN + maxBound = FeatureSet'LEGACY_REQUIRED +instance Prelude.Enum FeatureSet'FieldPresence where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum FieldPresence: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'FIELD_PRESENCE_UNKNOWN = 0 + fromEnum FeatureSet'EXPLICIT = 1 + fromEnum FeatureSet'IMPLICIT = 2 + fromEnum FeatureSet'LEGACY_REQUIRED = 3 + succ FeatureSet'LEGACY_REQUIRED + = Prelude.error + "FeatureSet'FieldPresence.succ: bad argument FeatureSet'LEGACY_REQUIRED. This value would be out of bounds." + succ FeatureSet'FIELD_PRESENCE_UNKNOWN = FeatureSet'EXPLICIT + succ FeatureSet'EXPLICIT = FeatureSet'IMPLICIT + succ FeatureSet'IMPLICIT = FeatureSet'LEGACY_REQUIRED + pred FeatureSet'FIELD_PRESENCE_UNKNOWN + = Prelude.error + "FeatureSet'FieldPresence.pred: bad argument FeatureSet'FIELD_PRESENCE_UNKNOWN. This value would be out of bounds." + pred FeatureSet'EXPLICIT = FeatureSet'FIELD_PRESENCE_UNKNOWN + pred FeatureSet'IMPLICIT = FeatureSet'EXPLICIT + pred FeatureSet'LEGACY_REQUIRED = FeatureSet'IMPLICIT + 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 Data.ProtoLens.FieldDefault FeatureSet'FieldPresence where + fieldDefault = FeatureSet'FIELD_PRESENCE_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'FieldPresence where + rnf x__ = Prelude.seq x__ () +data FeatureSet'JsonFormat + = FeatureSet'JSON_FORMAT_UNKNOWN | + FeatureSet'ALLOW | + FeatureSet'LEGACY_BEST_EFFORT + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'JsonFormat where + maybeToEnum 0 = Prelude.Just FeatureSet'JSON_FORMAT_UNKNOWN + maybeToEnum 1 = Prelude.Just FeatureSet'ALLOW + maybeToEnum 2 = Prelude.Just FeatureSet'LEGACY_BEST_EFFORT + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'JSON_FORMAT_UNKNOWN = "JSON_FORMAT_UNKNOWN" + showEnum FeatureSet'ALLOW = "ALLOW" + showEnum FeatureSet'LEGACY_BEST_EFFORT = "LEGACY_BEST_EFFORT" + readEnum k + | (Prelude.==) k "JSON_FORMAT_UNKNOWN" + = Prelude.Just FeatureSet'JSON_FORMAT_UNKNOWN + | (Prelude.==) k "ALLOW" = Prelude.Just FeatureSet'ALLOW + | (Prelude.==) k "LEGACY_BEST_EFFORT" + = Prelude.Just FeatureSet'LEGACY_BEST_EFFORT + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'JsonFormat where + minBound = FeatureSet'JSON_FORMAT_UNKNOWN + maxBound = FeatureSet'LEGACY_BEST_EFFORT +instance Prelude.Enum FeatureSet'JsonFormat where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum JsonFormat: " (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'JSON_FORMAT_UNKNOWN = 0 + fromEnum FeatureSet'ALLOW = 1 + fromEnum FeatureSet'LEGACY_BEST_EFFORT = 2 + succ FeatureSet'LEGACY_BEST_EFFORT + = Prelude.error + "FeatureSet'JsonFormat.succ: bad argument FeatureSet'LEGACY_BEST_EFFORT. This value would be out of bounds." + succ FeatureSet'JSON_FORMAT_UNKNOWN = FeatureSet'ALLOW + succ FeatureSet'ALLOW = FeatureSet'LEGACY_BEST_EFFORT + pred FeatureSet'JSON_FORMAT_UNKNOWN + = Prelude.error + "FeatureSet'JsonFormat.pred: bad argument FeatureSet'JSON_FORMAT_UNKNOWN. This value would be out of bounds." + pred FeatureSet'ALLOW = FeatureSet'JSON_FORMAT_UNKNOWN + pred FeatureSet'LEGACY_BEST_EFFORT = FeatureSet'ALLOW + 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 Data.ProtoLens.FieldDefault FeatureSet'JsonFormat where + fieldDefault = FeatureSet'JSON_FORMAT_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'JsonFormat where + rnf x__ = Prelude.seq x__ () +data FeatureSet'MessageEncoding + = FeatureSet'MESSAGE_ENCODING_UNKNOWN | + FeatureSet'LENGTH_PREFIXED | + FeatureSet'DELIMITED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'MessageEncoding where + maybeToEnum 0 = Prelude.Just FeatureSet'MESSAGE_ENCODING_UNKNOWN + maybeToEnum 1 = Prelude.Just FeatureSet'LENGTH_PREFIXED + maybeToEnum 2 = Prelude.Just FeatureSet'DELIMITED + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'MESSAGE_ENCODING_UNKNOWN + = "MESSAGE_ENCODING_UNKNOWN" + showEnum FeatureSet'LENGTH_PREFIXED = "LENGTH_PREFIXED" + showEnum FeatureSet'DELIMITED = "DELIMITED" + readEnum k + | (Prelude.==) k "MESSAGE_ENCODING_UNKNOWN" + = Prelude.Just FeatureSet'MESSAGE_ENCODING_UNKNOWN + | (Prelude.==) k "LENGTH_PREFIXED" + = Prelude.Just FeatureSet'LENGTH_PREFIXED + | (Prelude.==) k "DELIMITED" = Prelude.Just FeatureSet'DELIMITED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'MessageEncoding where + minBound = FeatureSet'MESSAGE_ENCODING_UNKNOWN + maxBound = FeatureSet'DELIMITED +instance Prelude.Enum FeatureSet'MessageEncoding where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum MessageEncoding: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'MESSAGE_ENCODING_UNKNOWN = 0 + fromEnum FeatureSet'LENGTH_PREFIXED = 1 + fromEnum FeatureSet'DELIMITED = 2 + succ FeatureSet'DELIMITED + = Prelude.error + "FeatureSet'MessageEncoding.succ: bad argument FeatureSet'DELIMITED. This value would be out of bounds." + succ FeatureSet'MESSAGE_ENCODING_UNKNOWN + = FeatureSet'LENGTH_PREFIXED + succ FeatureSet'LENGTH_PREFIXED = FeatureSet'DELIMITED + pred FeatureSet'MESSAGE_ENCODING_UNKNOWN + = Prelude.error + "FeatureSet'MessageEncoding.pred: bad argument FeatureSet'MESSAGE_ENCODING_UNKNOWN. This value would be out of bounds." + pred FeatureSet'LENGTH_PREFIXED + = FeatureSet'MESSAGE_ENCODING_UNKNOWN + pred FeatureSet'DELIMITED = FeatureSet'LENGTH_PREFIXED + 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 Data.ProtoLens.FieldDefault FeatureSet'MessageEncoding where + fieldDefault = FeatureSet'MESSAGE_ENCODING_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'MessageEncoding where + rnf x__ = Prelude.seq x__ () +data FeatureSet'RepeatedFieldEncoding + = FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN | + FeatureSet'PACKED | + FeatureSet'EXPANDED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'RepeatedFieldEncoding where + maybeToEnum 0 + = Prelude.Just FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + maybeToEnum 1 = Prelude.Just FeatureSet'PACKED + maybeToEnum 2 = Prelude.Just FeatureSet'EXPANDED + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + = "REPEATED_FIELD_ENCODING_UNKNOWN" + showEnum FeatureSet'PACKED = "PACKED" + showEnum FeatureSet'EXPANDED = "EXPANDED" + readEnum k + | (Prelude.==) k "REPEATED_FIELD_ENCODING_UNKNOWN" + = Prelude.Just FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + | (Prelude.==) k "PACKED" = Prelude.Just FeatureSet'PACKED + | (Prelude.==) k "EXPANDED" = Prelude.Just FeatureSet'EXPANDED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'RepeatedFieldEncoding where + minBound = FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + maxBound = FeatureSet'EXPANDED +instance Prelude.Enum FeatureSet'RepeatedFieldEncoding where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum RepeatedFieldEncoding: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN = 0 + fromEnum FeatureSet'PACKED = 1 + fromEnum FeatureSet'EXPANDED = 2 + succ FeatureSet'EXPANDED + = Prelude.error + "FeatureSet'RepeatedFieldEncoding.succ: bad argument FeatureSet'EXPANDED. This value would be out of bounds." + succ FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN = FeatureSet'PACKED + succ FeatureSet'PACKED = FeatureSet'EXPANDED + pred FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + = Prelude.error + "FeatureSet'RepeatedFieldEncoding.pred: bad argument FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN. This value would be out of bounds." + pred FeatureSet'PACKED = FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN + pred FeatureSet'EXPANDED = FeatureSet'PACKED + 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 Data.ProtoLens.FieldDefault FeatureSet'RepeatedFieldEncoding where + fieldDefault = FeatureSet'REPEATED_FIELD_ENCODING_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'RepeatedFieldEncoding where + rnf x__ = Prelude.seq x__ () +data FeatureSet'Utf8Validation + = FeatureSet'UTF8_VALIDATION_UNKNOWN | + FeatureSet'VERIFY | + FeatureSet'NONE + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FeatureSet'Utf8Validation where + maybeToEnum 0 = Prelude.Just FeatureSet'UTF8_VALIDATION_UNKNOWN + maybeToEnum 2 = Prelude.Just FeatureSet'VERIFY + maybeToEnum 3 = Prelude.Just FeatureSet'NONE + maybeToEnum _ = Prelude.Nothing + showEnum FeatureSet'UTF8_VALIDATION_UNKNOWN + = "UTF8_VALIDATION_UNKNOWN" + showEnum FeatureSet'VERIFY = "VERIFY" + showEnum FeatureSet'NONE = "NONE" + readEnum k + | (Prelude.==) k "UTF8_VALIDATION_UNKNOWN" + = Prelude.Just FeatureSet'UTF8_VALIDATION_UNKNOWN + | (Prelude.==) k "VERIFY" = Prelude.Just FeatureSet'VERIFY + | (Prelude.==) k "NONE" = Prelude.Just FeatureSet'NONE + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FeatureSet'Utf8Validation where + minBound = FeatureSet'UTF8_VALIDATION_UNKNOWN + maxBound = FeatureSet'NONE +instance Prelude.Enum FeatureSet'Utf8Validation where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum Utf8Validation: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FeatureSet'UTF8_VALIDATION_UNKNOWN = 0 + fromEnum FeatureSet'VERIFY = 2 + fromEnum FeatureSet'NONE = 3 + succ FeatureSet'NONE + = Prelude.error + "FeatureSet'Utf8Validation.succ: bad argument FeatureSet'NONE. This value would be out of bounds." + succ FeatureSet'UTF8_VALIDATION_UNKNOWN = FeatureSet'VERIFY + succ FeatureSet'VERIFY = FeatureSet'NONE + pred FeatureSet'UTF8_VALIDATION_UNKNOWN + = Prelude.error + "FeatureSet'Utf8Validation.pred: bad argument FeatureSet'UTF8_VALIDATION_UNKNOWN. This value would be out of bounds." + pred FeatureSet'VERIFY = FeatureSet'UTF8_VALIDATION_UNKNOWN + pred FeatureSet'NONE = FeatureSet'VERIFY + 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 Data.ProtoLens.FieldDefault FeatureSet'Utf8Validation where + fieldDefault = FeatureSet'UTF8_VALIDATION_UNKNOWN +instance Control.DeepSeq.NFData FeatureSet'Utf8Validation where + rnf x__ = Prelude.seq x__ () +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.defaults' @:: Lens' FeatureSetDefaults [FeatureSetDefaults'FeatureSetEditionDefault]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'defaults' @:: Lens' FeatureSetDefaults (Data.Vector.Vector FeatureSetDefaults'FeatureSetEditionDefault)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.minimumEdition' @:: Lens' FeatureSetDefaults Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'minimumEdition' @:: Lens' FeatureSetDefaults (Prelude.Maybe Edition)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maximumEdition' @:: Lens' FeatureSetDefaults Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'maximumEdition' @:: Lens' FeatureSetDefaults (Prelude.Maybe Edition)@ -} +data FeatureSetDefaults + = FeatureSetDefaults'_constructor {_FeatureSetDefaults'defaults :: !(Data.Vector.Vector FeatureSetDefaults'FeatureSetEditionDefault), + _FeatureSetDefaults'minimumEdition :: !(Prelude.Maybe Edition), + _FeatureSetDefaults'maximumEdition :: !(Prelude.Maybe Edition), + _FeatureSetDefaults'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FeatureSetDefaults where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "defaults" [FeatureSetDefaults'FeatureSetEditionDefault] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'defaults + (\ x__ y__ -> x__ {_FeatureSetDefaults'defaults = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "vec'defaults" (Data.Vector.Vector FeatureSetDefaults'FeatureSetEditionDefault) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'defaults + (\ x__ y__ -> x__ {_FeatureSetDefaults'defaults = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "minimumEdition" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'minimumEdition + (\ x__ y__ -> x__ {_FeatureSetDefaults'minimumEdition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "maybe'minimumEdition" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'minimumEdition + (\ x__ y__ -> x__ {_FeatureSetDefaults'minimumEdition = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "maximumEdition" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'maximumEdition + (\ x__ y__ -> x__ {_FeatureSetDefaults'maximumEdition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults "maybe'maximumEdition" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'maximumEdition + (\ x__ y__ -> x__ {_FeatureSetDefaults'maximumEdition = y__})) + Prelude.id +instance Data.ProtoLens.Message FeatureSetDefaults where + messageName _ = Data.Text.pack "google.protobuf.FeatureSetDefaults" + packedMessageDescriptor _ + = "\n\ + \\DC2FeatureSetDefaults\DC2X\n\ + \\bdefaults\CAN\SOH \ETX(\v2<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\bdefaults\DC2A\n\ + \\SIminimum_edition\CAN\EOT \SOH(\SO2\CAN.google.protobuf.EditionR\SOminimumEdition\DC2A\n\ + \\SImaximum_edition\CAN\ENQ \SOH(\SO2\CAN.google.protobuf.EditionR\SOmaximumEdition\SUB\248\SOH\n\ + \\CANFeatureSetEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2N\n\ + \\DC4overridable_features\CAN\EOT \SOH(\v2\ESC.google.protobuf.FeatureSetR\DC3overridableFeatures\DC2B\n\ + \\SOfixed_features\CAN\ENQ \SOH(\v2\ESC.google.protobuf.FeatureSetR\rfixedFeaturesJ\EOT\b\SOH\DLE\STXJ\EOT\b\STX\DLE\ETXR\bfeatures" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + defaults__field_descriptor + = Data.ProtoLens.FieldDescriptor + "defaults" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSetDefaults'FeatureSetEditionDefault) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"defaults")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults + minimumEdition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "minimum_edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'minimumEdition")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults + maximumEdition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "maximum_edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'maximumEdition")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, defaults__field_descriptor), + (Data.ProtoLens.Tag 4, minimumEdition__field_descriptor), + (Data.ProtoLens.Tag 5, maximumEdition__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FeatureSetDefaults'_unknownFields + (\ x__ y__ -> x__ {_FeatureSetDefaults'_unknownFields = y__}) + defMessage + = FeatureSetDefaults'_constructor + {_FeatureSetDefaults'defaults = Data.Vector.Generic.empty, + _FeatureSetDefaults'minimumEdition = Prelude.Nothing, + _FeatureSetDefaults'maximumEdition = Prelude.Nothing, + _FeatureSetDefaults'_unknownFields = []} + parseMessage + = let + loop :: + FeatureSetDefaults + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FeatureSetDefaults'FeatureSetEditionDefault + -> Data.ProtoLens.Encoding.Bytes.Parser FeatureSetDefaults + loop x mutable'defaults + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'defaults <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'defaults) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'defaults") frozen'defaults x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "defaults" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'defaults y) + loop x v + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "minimum_edition" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"minimumEdition") y x) + mutable'defaults + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "maximum_edition" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"maximumEdition") y x) + mutable'defaults + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'defaults + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'defaults <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'defaults) + "FeatureSetDefaults" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'defaults") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'minimumEdition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'maximumEdition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData FeatureSetDefaults where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FeatureSetDefaults'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'defaults x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'minimumEdition x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'maximumEdition x__) ()))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.edition' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'edition' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault (Prelude.Maybe Edition)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.overridableFeatures' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'overridableFeatures' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.fixedFeatures' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'fixedFeatures' @:: Lens' FeatureSetDefaults'FeatureSetEditionDefault (Prelude.Maybe FeatureSet)@ -} +data FeatureSetDefaults'FeatureSetEditionDefault + = FeatureSetDefaults'FeatureSetEditionDefault'_constructor {_FeatureSetDefaults'FeatureSetEditionDefault'edition :: !(Prelude.Maybe Edition), + _FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures :: !(Prelude.Maybe FeatureSet), + _FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures :: !(Prelude.Maybe FeatureSet), + _FeatureSetDefaults'FeatureSetEditionDefault'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FeatureSetDefaults'FeatureSetEditionDefault where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "edition" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'edition + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'edition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "maybe'edition" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'edition + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'edition = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "overridableFeatures" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "maybe'overridableFeatures" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "fixedFeatures" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FeatureSetDefaults'FeatureSetEditionDefault "maybe'fixedFeatures" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures = y__})) + Prelude.id +instance Data.ProtoLens.Message FeatureSetDefaults'FeatureSetEditionDefault where + messageName _ + = Data.Text.pack + "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" + packedMessageDescriptor _ + = "\n\ + \\CANFeatureSetEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2N\n\ + \\DC4overridable_features\CAN\EOT \SOH(\v2\ESC.google.protobuf.FeatureSetR\DC3overridableFeatures\DC2B\n\ + \\SOfixed_features\CAN\ENQ \SOH(\v2\ESC.google.protobuf.FeatureSetR\rfixedFeaturesJ\EOT\b\SOH\DLE\STXJ\EOT\b\STX\DLE\ETXR\bfeatures" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + edition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'edition")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults'FeatureSetEditionDefault + overridableFeatures__field_descriptor + = Data.ProtoLens.FieldDescriptor + "overridable_features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'overridableFeatures")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults'FeatureSetEditionDefault + fixedFeatures__field_descriptor + = Data.ProtoLens.FieldDescriptor + "fixed_features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'fixedFeatures")) :: + Data.ProtoLens.FieldDescriptor FeatureSetDefaults'FeatureSetEditionDefault + in + Data.Map.fromList + [(Data.ProtoLens.Tag 3, edition__field_descriptor), + (Data.ProtoLens.Tag 4, overridableFeatures__field_descriptor), + (Data.ProtoLens.Tag 5, fixedFeatures__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FeatureSetDefaults'FeatureSetEditionDefault'_unknownFields + (\ x__ y__ + -> x__ + {_FeatureSetDefaults'FeatureSetEditionDefault'_unknownFields = y__}) + defMessage + = FeatureSetDefaults'FeatureSetEditionDefault'_constructor + {_FeatureSetDefaults'FeatureSetEditionDefault'edition = Prelude.Nothing, + _FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures = Prelude.Nothing, + _FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures = Prelude.Nothing, + _FeatureSetDefaults'FeatureSetEditionDefault'_unknownFields = []} + parseMessage + = let + loop :: + FeatureSetDefaults'FeatureSetEditionDefault + -> Data.ProtoLens.Encoding.Bytes.Parser FeatureSetDefaults'FeatureSetEditionDefault + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"edition") y x) + 34 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "overridable_features" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"overridableFeatures") y x) + 42 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "fixed_features" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"fixedFeatures") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "FeatureSetEditionDefault" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'edition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'overridableFeatures") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'fixedFeatures") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 42) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData FeatureSetDefaults'FeatureSetEditionDefault where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FeatureSetDefaults'FeatureSetEditionDefault'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'FeatureSetEditionDefault'edition x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'FeatureSetEditionDefault'overridableFeatures + x__) + (Control.DeepSeq.deepseq + (_FeatureSetDefaults'FeatureSetEditionDefault'fixedFeatures x__) + ()))) +{- | 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)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.proto3Optional' @:: Lens' FieldDescriptorProto Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'proto3Optional' @:: Lens' FieldDescriptorProto (Prelude.Maybe Prelude.Bool)@ -} +data FieldDescriptorProto + = FieldDescriptorProto'_constructor {_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'proto3Optional :: !(Prelude.Maybe Prelude.Bool), + _FieldDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FieldDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'name + (\ x__ y__ -> x__ {_FieldDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'name + (\ x__ y__ -> x__ {_FieldDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "number" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'number + (\ x__ y__ -> x__ {_FieldDescriptorProto'number = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'number" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'number + (\ x__ y__ -> x__ {_FieldDescriptorProto'number = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "label" FieldDescriptorProto'Label where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'label + (\ x__ y__ -> x__ {_FieldDescriptorProto'label = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'label" (Prelude.Maybe FieldDescriptorProto'Label) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'label + (\ x__ y__ -> x__ {_FieldDescriptorProto'label = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "type'" FieldDescriptorProto'Type where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'type' + (\ x__ y__ -> x__ {_FieldDescriptorProto'type' = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'type'" (Prelude.Maybe FieldDescriptorProto'Type) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'type' + (\ x__ y__ -> x__ {_FieldDescriptorProto'type' = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "typeName" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'typeName + (\ x__ y__ -> x__ {_FieldDescriptorProto'typeName = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'typeName" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'typeName + (\ x__ y__ -> x__ {_FieldDescriptorProto'typeName = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "extendee" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'extendee + (\ x__ y__ -> x__ {_FieldDescriptorProto'extendee = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'extendee" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'extendee + (\ x__ y__ -> x__ {_FieldDescriptorProto'extendee = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "defaultValue" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'defaultValue + (\ x__ y__ -> x__ {_FieldDescriptorProto'defaultValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'defaultValue" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'defaultValue + (\ x__ y__ -> x__ {_FieldDescriptorProto'defaultValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "oneofIndex" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'oneofIndex + (\ x__ y__ -> x__ {_FieldDescriptorProto'oneofIndex = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'oneofIndex" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'oneofIndex + (\ x__ y__ -> x__ {_FieldDescriptorProto'oneofIndex = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "jsonName" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'jsonName + (\ x__ y__ -> x__ {_FieldDescriptorProto'jsonName = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'jsonName" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'jsonName + (\ x__ y__ -> x__ {_FieldDescriptorProto'jsonName = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "options" FieldOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'options + (\ x__ y__ -> x__ {_FieldDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'options" (Prelude.Maybe FieldOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'options + (\ x__ y__ -> x__ {_FieldDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "proto3Optional" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'proto3Optional + (\ x__ y__ -> x__ {_FieldDescriptorProto'proto3Optional = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'proto3Optional" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldDescriptorProto'proto3Optional + (\ x__ y__ -> x__ {_FieldDescriptorProto'proto3Optional = y__})) + Prelude.id +instance Data.ProtoLens.Message FieldDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FieldDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\DC4FieldDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\SYN\n\ + \\ACKnumber\CAN\ETX \SOH(\ENQR\ACKnumber\DC2A\n\ + \\ENQlabel\CAN\EOT \SOH(\SO2+.google.protobuf.FieldDescriptorProto.LabelR\ENQlabel\DC2>\n\ + \\EOTtype\CAN\ENQ \SOH(\SO2*.google.protobuf.FieldDescriptorProto.TypeR\EOTtype\DC2\ESC\n\ + \\ttype_name\CAN\ACK \SOH(\tR\btypeName\DC2\SUB\n\ + \\bextendee\CAN\STX \SOH(\tR\bextendee\DC2#\n\ + \\rdefault_value\CAN\a \SOH(\tR\fdefaultValue\DC2\US\n\ + \\voneof_index\CAN\t \SOH(\ENQR\n\ + \oneofIndex\DC2\ESC\n\ + \\tjson_name\CAN\n\ + \ \SOH(\tR\bjsonName\DC27\n\ + \\aoptions\CAN\b \SOH(\v2\GS.google.protobuf.FieldOptionsR\aoptions\DC2'\n\ + \\SIproto3_optional\CAN\DC1 \SOH(\bR\SOproto3Optional\"\182\STX\n\ + \\EOTType\DC2\SI\n\ + \\vTYPE_DOUBLE\DLE\SOH\DC2\SO\n\ + \\n\ + \TYPE_FLOAT\DLE\STX\DC2\SO\n\ + \\n\ + \TYPE_INT64\DLE\ETX\DC2\SI\n\ + \\vTYPE_UINT64\DLE\EOT\DC2\SO\n\ + \\n\ + \TYPE_INT32\DLE\ENQ\DC2\DLE\n\ + \\fTYPE_FIXED64\DLE\ACK\DC2\DLE\n\ + \\fTYPE_FIXED32\DLE\a\DC2\r\n\ + \\tTYPE_BOOL\DLE\b\DC2\SI\n\ + \\vTYPE_STRING\DLE\t\DC2\SO\n\ + \\n\ + \TYPE_GROUP\DLE\n\ + \\DC2\DLE\n\ + \\fTYPE_MESSAGE\DLE\v\DC2\SO\n\ + \\n\ + \TYPE_BYTES\DLE\f\DC2\SI\n\ + \\vTYPE_UINT32\DLE\r\DC2\r\n\ + \\tTYPE_ENUM\DLE\SO\DC2\DC1\n\ + \\rTYPE_SFIXED32\DLE\SI\DC2\DC1\n\ + \\rTYPE_SFIXED64\DLE\DLE\DC2\SI\n\ + \\vTYPE_SINT32\DLE\DC1\DC2\SI\n\ + \\vTYPE_SINT64\DLE\DC2\"C\n\ + \\ENQLabel\DC2\DC2\n\ + \\SOLABEL_OPTIONAL\DLE\SOH\DC2\DC2\n\ + \\SOLABEL_REPEATED\DLE\ETX\DC2\DC2\n\ + \\SOLABEL_REQUIRED\DLE\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'options")) :: + Data.ProtoLens.FieldDescriptor FieldDescriptorProto + proto3Optional__field_descriptor + = Data.ProtoLens.FieldDescriptor + "proto3_optional" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'proto3Optional")) :: + 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), + (Data.ProtoLens.Tag 17, proto3Optional__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_FieldDescriptorProto'_unknownFields = y__}) + defMessage + = FieldDescriptorProto'_constructor + {_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'proto3Optional = Prelude.Nothing, + _FieldDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + FieldDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser FieldDescriptorProto + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "number" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"number") y x) + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "label" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"label") y x) + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "type" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"type'") y x) + 50 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "type_name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"typeName") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "extendee" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"extendee") y x) + 58 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "default_value" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"defaultValue") y x) + 72 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "oneof_index" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"oneofIndex") y x) + 82 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "json_name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"jsonName") y x) + 66 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + 136 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "proto3_optional" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"proto3Optional") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "FieldDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'label") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'type'") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'typeName") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 50) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'extendee") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'defaultValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 58) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'oneofIndex") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 72) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'jsonName") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 82) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 66) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'proto3Optional") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 136) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view + Data.ProtoLens.unknownFields _x)))))))))))) +instance Control.DeepSeq.NFData FieldDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FieldDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'number x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'label x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'type' x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'typeName x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'extendee x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'defaultValue x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'oneofIndex x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'jsonName x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'options x__) + (Control.DeepSeq.deepseq + (_FieldDescriptorProto'proto3Optional x__) + ()))))))))))) +data FieldDescriptorProto'Label + = FieldDescriptorProto'LABEL_OPTIONAL | + FieldDescriptorProto'LABEL_REQUIRED | + FieldDescriptorProto'LABEL_REPEATED + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +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_REPEATED = "LABEL_REPEATED" + showEnum FieldDescriptorProto'LABEL_REQUIRED = "LABEL_REQUIRED" + readEnum k + | (Prelude.==) k "LABEL_OPTIONAL" + = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL + | (Prelude.==) k "LABEL_REPEATED" + = Prelude.Just FieldDescriptorProto'LABEL_REPEATED + | (Prelude.==) k "LABEL_REQUIRED" + = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldDescriptorProto'Label where + minBound = FieldDescriptorProto'LABEL_OPTIONAL + maxBound = FieldDescriptorProto'LABEL_REPEATED +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 Data.ProtoLens.FieldDefault FieldDescriptorProto'Label where + fieldDefault = FieldDescriptorProto'LABEL_OPTIONAL +instance Control.DeepSeq.NFData FieldDescriptorProto'Label where + rnf x__ = Prelude.seq x__ () +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 stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +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 k + | (Prelude.==) k "TYPE_DOUBLE" + = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE + | (Prelude.==) k "TYPE_FLOAT" + = Prelude.Just FieldDescriptorProto'TYPE_FLOAT + | (Prelude.==) k "TYPE_INT64" + = Prelude.Just FieldDescriptorProto'TYPE_INT64 + | (Prelude.==) k "TYPE_UINT64" + = Prelude.Just FieldDescriptorProto'TYPE_UINT64 + | (Prelude.==) k "TYPE_INT32" + = Prelude.Just FieldDescriptorProto'TYPE_INT32 + | (Prelude.==) k "TYPE_FIXED64" + = Prelude.Just FieldDescriptorProto'TYPE_FIXED64 + | (Prelude.==) k "TYPE_FIXED32" + = Prelude.Just FieldDescriptorProto'TYPE_FIXED32 + | (Prelude.==) k "TYPE_BOOL" + = Prelude.Just FieldDescriptorProto'TYPE_BOOL + | (Prelude.==) k "TYPE_STRING" + = Prelude.Just FieldDescriptorProto'TYPE_STRING + | (Prelude.==) k "TYPE_GROUP" + = Prelude.Just FieldDescriptorProto'TYPE_GROUP + | (Prelude.==) k "TYPE_MESSAGE" + = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE + | (Prelude.==) k "TYPE_BYTES" + = Prelude.Just FieldDescriptorProto'TYPE_BYTES + | (Prelude.==) k "TYPE_UINT32" + = Prelude.Just FieldDescriptorProto'TYPE_UINT32 + | (Prelude.==) k "TYPE_ENUM" + = Prelude.Just FieldDescriptorProto'TYPE_ENUM + | (Prelude.==) k "TYPE_SFIXED32" + = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32 + | (Prelude.==) k "TYPE_SFIXED64" + = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64 + | (Prelude.==) k "TYPE_SINT32" + = Prelude.Just FieldDescriptorProto'TYPE_SINT32 + | (Prelude.==) k "TYPE_SINT64" + = Prelude.Just FieldDescriptorProto'TYPE_SINT64 + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldDescriptorProto'Type where + minBound = FieldDescriptorProto'TYPE_DOUBLE + maxBound = FieldDescriptorProto'TYPE_SINT64 +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 Data.ProtoLens.FieldDefault FieldDescriptorProto'Type where + fieldDefault = FieldDescriptorProto'TYPE_DOUBLE +instance Control.DeepSeq.NFData FieldDescriptorProto'Type where + rnf x__ = Prelude.seq x__ () +{- | 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.unverifiedLazy' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'unverifiedLazy' @:: 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.debugRedact' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'debugRedact' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.retention' @:: Lens' FieldOptions FieldOptions'OptionRetention@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'retention' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'OptionRetention)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.targets' @:: Lens' FieldOptions [FieldOptions'OptionTargetType]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'targets' @:: Lens' FieldOptions (Data.Vector.Vector FieldOptions'OptionTargetType)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.editionDefaults' @:: Lens' FieldOptions [FieldOptions'EditionDefault]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'editionDefaults' @:: Lens' FieldOptions (Data.Vector.Vector FieldOptions'EditionDefault)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' FieldOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' FieldOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.featureSupport' @:: Lens' FieldOptions FieldOptions'FeatureSupport@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'featureSupport' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'FeatureSupport)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FieldOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' FieldOptions (Data.Vector.Vector UninterpretedOption)@ -} +data FieldOptions + = FieldOptions'_constructor {_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'unverifiedLazy :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'weak :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'debugRedact :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'retention :: !(Prelude.Maybe FieldOptions'OptionRetention), + _FieldOptions'targets :: !(Data.Vector.Vector FieldOptions'OptionTargetType), + _FieldOptions'editionDefaults :: !(Data.Vector.Vector FieldOptions'EditionDefault), + _FieldOptions'features :: !(Prelude.Maybe FeatureSet), + _FieldOptions'featureSupport :: !(Prelude.Maybe FieldOptions'FeatureSupport), + _FieldOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _FieldOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FieldOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FieldOptions "ctype" FieldOptions'CType where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'ctype (\ x__ y__ -> x__ {_FieldOptions'ctype = y__})) + (Data.ProtoLens.maybeLens FieldOptions'STRING) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'ctype" (Prelude.Maybe FieldOptions'CType) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'ctype (\ x__ y__ -> x__ {_FieldOptions'ctype = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "packed" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'packed + (\ x__ y__ -> x__ {_FieldOptions'packed = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'packed" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'packed + (\ x__ y__ -> x__ {_FieldOptions'packed = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "jstype" FieldOptions'JSType where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'jstype + (\ x__ y__ -> x__ {_FieldOptions'jstype = y__})) + (Data.ProtoLens.maybeLens FieldOptions'JS_NORMAL) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'jstype" (Prelude.Maybe FieldOptions'JSType) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'jstype + (\ x__ y__ -> x__ {_FieldOptions'jstype = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "lazy" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'lazy (\ x__ y__ -> x__ {_FieldOptions'lazy = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'lazy" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'lazy (\ x__ y__ -> x__ {_FieldOptions'lazy = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "unverifiedLazy" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'unverifiedLazy + (\ x__ y__ -> x__ {_FieldOptions'unverifiedLazy = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'unverifiedLazy" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'unverifiedLazy + (\ x__ y__ -> x__ {_FieldOptions'unverifiedLazy = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'deprecated + (\ x__ y__ -> x__ {_FieldOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'deprecated + (\ x__ y__ -> x__ {_FieldOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "weak" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'weak (\ x__ y__ -> x__ {_FieldOptions'weak = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'weak" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'weak (\ x__ y__ -> x__ {_FieldOptions'weak = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "debugRedact" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'debugRedact + (\ x__ y__ -> x__ {_FieldOptions'debugRedact = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'debugRedact" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'debugRedact + (\ x__ y__ -> x__ {_FieldOptions'debugRedact = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "retention" FieldOptions'OptionRetention where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'retention + (\ x__ y__ -> x__ {_FieldOptions'retention = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'retention" (Prelude.Maybe FieldOptions'OptionRetention) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'retention + (\ x__ y__ -> x__ {_FieldOptions'retention = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "targets" [FieldOptions'OptionTargetType] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'targets + (\ x__ y__ -> x__ {_FieldOptions'targets = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FieldOptions "vec'targets" (Data.Vector.Vector FieldOptions'OptionTargetType) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'targets + (\ x__ y__ -> x__ {_FieldOptions'targets = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "editionDefaults" [FieldOptions'EditionDefault] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'editionDefaults + (\ x__ y__ -> x__ {_FieldOptions'editionDefaults = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FieldOptions "vec'editionDefaults" (Data.Vector.Vector FieldOptions'EditionDefault) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'editionDefaults + (\ x__ y__ -> x__ {_FieldOptions'editionDefaults = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'features + (\ x__ y__ -> x__ {_FieldOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'features + (\ x__ y__ -> x__ {_FieldOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "featureSupport" FieldOptions'FeatureSupport where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'featureSupport + (\ x__ y__ -> x__ {_FieldOptions'featureSupport = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FieldOptions "maybe'featureSupport" (Prelude.Maybe FieldOptions'FeatureSupport) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'featureSupport + (\ x__ y__ -> x__ {_FieldOptions'featureSupport = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'uninterpretedOption + (\ x__ y__ -> x__ {_FieldOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FieldOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'uninterpretedOption + (\ x__ y__ -> x__ {_FieldOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message FieldOptions where + messageName _ = Data.Text.pack "google.protobuf.FieldOptions" + packedMessageDescriptor _ + = "\n\ + \\fFieldOptions\DC2A\n\ + \\ENQctype\CAN\SOH \SOH(\SO2#.google.protobuf.FieldOptions.CType:\ACKSTRINGR\ENQctype\DC2\SYN\n\ + \\ACKpacked\CAN\STX \SOH(\bR\ACKpacked\DC2G\n\ + \\ACKjstype\CAN\ACK \SOH(\SO2$.google.protobuf.FieldOptions.JSType:\tJS_NORMALR\ACKjstype\DC2\EM\n\ + \\EOTlazy\CAN\ENQ \SOH(\b:\ENQfalseR\EOTlazy\DC2.\n\ + \\SIunverified_lazy\CAN\SI \SOH(\b:\ENQfalseR\SOunverifiedLazy\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2\EM\n\ + \\EOTweak\CAN\n\ + \ \SOH(\b:\ENQfalseR\EOTweak\DC2(\n\ + \\fdebug_redact\CAN\DLE \SOH(\b:\ENQfalseR\vdebugRedact\DC2K\n\ + \\tretention\CAN\DC1 \SOH(\SO2-.google.protobuf.FieldOptions.OptionRetentionR\tretention\DC2H\n\ + \\atargets\CAN\DC3 \ETX(\SO2..google.protobuf.FieldOptions.OptionTargetTypeR\atargets\DC2W\n\ + \\DLEedition_defaults\CAN\DC4 \ETX(\v2,.google.protobuf.FieldOptions.EditionDefaultR\SIeditionDefaults\DC27\n\ + \\bfeatures\CAN\NAK \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2U\n\ + \\SIfeature_support\CAN\SYN \SOH(\v2,.google.protobuf.FieldOptions.FeatureSupportR\SOfeatureSupport\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\SUBZ\n\ + \\SOEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2\DC4\n\ + \\ENQvalue\CAN\STX \SOH(\tR\ENQvalue\SUB\150\STX\n\ + \\SOFeatureSupport\DC2G\n\ + \\DC2edition_introduced\CAN\SOH \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionIntroduced\DC2G\n\ + \\DC2edition_deprecated\CAN\STX \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionDeprecated\DC2/\n\ + \\DC3deprecation_warning\CAN\ETX \SOH(\tR\DC2deprecationWarning\DC2A\n\ + \\SIedition_removed\CAN\EOT \SOH(\SO2\CAN.google.protobuf.EditionR\SOeditionRemoved\"/\n\ + \\ENQCType\DC2\n\ + \\n\ + \\ACKSTRING\DLE\NUL\DC2\b\n\ + \\EOTCORD\DLE\SOH\DC2\DLE\n\ + \\fSTRING_PIECE\DLE\STX\"5\n\ + \\ACKJSType\DC2\r\n\ + \\tJS_NORMAL\DLE\NUL\DC2\r\n\ + \\tJS_STRING\DLE\SOH\DC2\r\n\ + \\tJS_NUMBER\DLE\STX\"U\n\ + \\SIOptionRetention\DC2\NAK\n\ + \\DC1RETENTION_UNKNOWN\DLE\NUL\DC2\NAK\n\ + \\DC1RETENTION_RUNTIME\DLE\SOH\DC2\DC4\n\ + \\DLERETENTION_SOURCE\DLE\STX\"\140\STX\n\ + \\DLEOptionTargetType\DC2\ETB\n\ + \\DC3TARGET_TYPE_UNKNOWN\DLE\NUL\DC2\DC4\n\ + \\DLETARGET_TYPE_FILE\DLE\SOH\DC2\US\n\ + \\ESCTARGET_TYPE_EXTENSION_RANGE\DLE\STX\DC2\ETB\n\ + \\DC3TARGET_TYPE_MESSAGE\DLE\ETX\DC2\NAK\n\ + \\DC1TARGET_TYPE_FIELD\DLE\EOT\DC2\NAK\n\ + \\DC1TARGET_TYPE_ONEOF\DLE\ENQ\DC2\DC4\n\ + \\DLETARGET_TYPE_ENUM\DLE\ACK\DC2\SUB\n\ + \\SYNTARGET_TYPE_ENUM_ENTRY\DLE\a\DC2\ETB\n\ + \\DC3TARGET_TYPE_SERVICE\DLE\b\DC2\SYN\n\ + \\DC2TARGET_TYPE_METHOD\DLE\t*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\EOT\DLE\ENQJ\EOT\b\DC2\DLE\DC3" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + ctype__field_descriptor + = Data.ProtoLens.FieldDescriptor + "ctype" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'CType) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'lazy")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + unverifiedLazy__field_descriptor + = Data.ProtoLens.FieldDescriptor + "unverified_lazy" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'unverifiedLazy")) :: + 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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'weak")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + debugRedact__field_descriptor + = Data.ProtoLens.FieldDescriptor + "debug_redact" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'debugRedact")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + retention__field_descriptor + = Data.ProtoLens.FieldDescriptor + "retention" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'OptionRetention) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'retention")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + targets__field_descriptor + = Data.ProtoLens.FieldDescriptor + "targets" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'OptionTargetType) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"targets")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + editionDefaults__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition_defaults" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'EditionDefault) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"editionDefaults")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + Data.ProtoLens.FieldDescriptor FieldOptions + featureSupport__field_descriptor + = Data.ProtoLens.FieldDescriptor + "feature_support" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FieldOptions'FeatureSupport) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'featureSupport")) :: + 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 + (Data.ProtoLens.Field.field @"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 15, unverifiedLazy__field_descriptor), + (Data.ProtoLens.Tag 3, deprecated__field_descriptor), + (Data.ProtoLens.Tag 10, weak__field_descriptor), + (Data.ProtoLens.Tag 16, debugRedact__field_descriptor), + (Data.ProtoLens.Tag 17, retention__field_descriptor), + (Data.ProtoLens.Tag 19, targets__field_descriptor), + (Data.ProtoLens.Tag 20, editionDefaults__field_descriptor), + (Data.ProtoLens.Tag 21, features__field_descriptor), + (Data.ProtoLens.Tag 22, featureSupport__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldOptions'_unknownFields + (\ x__ y__ -> x__ {_FieldOptions'_unknownFields = y__}) + defMessage + = FieldOptions'_constructor + {_FieldOptions'ctype = Prelude.Nothing, + _FieldOptions'packed = Prelude.Nothing, + _FieldOptions'jstype = Prelude.Nothing, + _FieldOptions'lazy = Prelude.Nothing, + _FieldOptions'unverifiedLazy = Prelude.Nothing, + _FieldOptions'deprecated = Prelude.Nothing, + _FieldOptions'weak = Prelude.Nothing, + _FieldOptions'debugRedact = Prelude.Nothing, + _FieldOptions'retention = Prelude.Nothing, + _FieldOptions'targets = Data.Vector.Generic.empty, + _FieldOptions'editionDefaults = Data.Vector.Generic.empty, + _FieldOptions'features = Prelude.Nothing, + _FieldOptions'featureSupport = Prelude.Nothing, + _FieldOptions'uninterpretedOption = Data.Vector.Generic.empty, + _FieldOptions'_unknownFields = []} + parseMessage + = let + loop :: + FieldOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldOptions'EditionDefault + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldOptions'OptionTargetType + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser FieldOptions + loop + x + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'editionDefaults <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'editionDefaults) + frozen'targets <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'targets) + frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'editionDefaults") + frozen'editionDefaults + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'targets") + frozen'targets + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "ctype" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"ctype") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "packed" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"packed") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 48 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "jstype" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"jstype") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "lazy" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"lazy") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 120 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "unverified_lazy" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"unverifiedLazy") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 80 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "weak" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"weak") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 128 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "debug_redact" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"debugRedact") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 136 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "retention" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"retention") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 152 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "targets" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'targets y) + loop x mutable'editionDefaults v mutable'uninterpretedOption + 154 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "targets" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'targets) + loop x mutable'editionDefaults y mutable'uninterpretedOption + 162 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "edition_defaults" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'editionDefaults y) + loop x v mutable'targets mutable'uninterpretedOption + 170 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 178 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "feature_support" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"featureSupport") y x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x mutable'editionDefaults mutable'targets v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'editionDefaults <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'targets <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'editionDefaults + mutable'targets + mutable'uninterpretedOption) + "FieldOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'ctype") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'packed") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'jstype") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 48) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'lazy") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'unverifiedLazy") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 120) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'weak") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 80) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'debugRedact") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 128) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'retention") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 136) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 152) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'targets") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 162) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'editionDefaults") + _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'features") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 170) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'featureSupport") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 178) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field + @"vec'uninterpretedOption") + _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view + Data.ProtoLens.unknownFields + _x))))))))))))))) +instance Control.DeepSeq.NFData FieldOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FieldOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FieldOptions'ctype x__) + (Control.DeepSeq.deepseq + (_FieldOptions'packed x__) + (Control.DeepSeq.deepseq + (_FieldOptions'jstype x__) + (Control.DeepSeq.deepseq + (_FieldOptions'lazy x__) + (Control.DeepSeq.deepseq + (_FieldOptions'unverifiedLazy x__) + (Control.DeepSeq.deepseq + (_FieldOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_FieldOptions'weak x__) + (Control.DeepSeq.deepseq + (_FieldOptions'debugRedact x__) + (Control.DeepSeq.deepseq + (_FieldOptions'retention x__) + (Control.DeepSeq.deepseq + (_FieldOptions'targets x__) + (Control.DeepSeq.deepseq + (_FieldOptions'editionDefaults x__) + (Control.DeepSeq.deepseq + (_FieldOptions'features x__) + (Control.DeepSeq.deepseq + (_FieldOptions'featureSupport x__) + (Control.DeepSeq.deepseq + (_FieldOptions'uninterpretedOption x__) + ())))))))))))))) +data FieldOptions'CType + = FieldOptions'STRING | + FieldOptions'CORD | + FieldOptions'STRING_PIECE + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +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 k + | (Prelude.==) k "STRING" = Prelude.Just FieldOptions'STRING + | (Prelude.==) k "CORD" = Prelude.Just FieldOptions'CORD + | (Prelude.==) k "STRING_PIECE" + = Prelude.Just FieldOptions'STRING_PIECE + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldOptions'CType where + minBound = FieldOptions'STRING + maxBound = FieldOptions'STRING_PIECE +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 Data.ProtoLens.FieldDefault FieldOptions'CType where + fieldDefault = FieldOptions'STRING +instance Control.DeepSeq.NFData FieldOptions'CType where + rnf x__ = Prelude.seq x__ () +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.edition' @:: Lens' FieldOptions'EditionDefault Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'edition' @:: Lens' FieldOptions'EditionDefault (Prelude.Maybe Edition)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.value' @:: Lens' FieldOptions'EditionDefault Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'value' @:: Lens' FieldOptions'EditionDefault (Prelude.Maybe Data.Text.Text)@ -} +data FieldOptions'EditionDefault + = FieldOptions'EditionDefault'_constructor {_FieldOptions'EditionDefault'edition :: !(Prelude.Maybe Edition), + _FieldOptions'EditionDefault'value :: !(Prelude.Maybe Data.Text.Text), + _FieldOptions'EditionDefault'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FieldOptions'EditionDefault where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FieldOptions'EditionDefault "edition" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'EditionDefault'edition + (\ x__ y__ -> x__ {_FieldOptions'EditionDefault'edition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'EditionDefault "maybe'edition" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'EditionDefault'edition + (\ x__ y__ -> x__ {_FieldOptions'EditionDefault'edition = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions'EditionDefault "value" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'EditionDefault'value + (\ x__ y__ -> x__ {_FieldOptions'EditionDefault'value = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'EditionDefault "maybe'value" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'EditionDefault'value + (\ x__ y__ -> x__ {_FieldOptions'EditionDefault'value = y__})) + Prelude.id +instance Data.ProtoLens.Message FieldOptions'EditionDefault where + messageName _ + = Data.Text.pack "google.protobuf.FieldOptions.EditionDefault" + packedMessageDescriptor _ + = "\n\ + \\SOEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2\DC4\n\ + \\ENQvalue\CAN\STX \SOH(\tR\ENQvalue" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + edition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'edition")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'EditionDefault + value__field_descriptor + = Data.ProtoLens.FieldDescriptor + "value" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'value")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'EditionDefault + in + Data.Map.fromList + [(Data.ProtoLens.Tag 3, edition__field_descriptor), + (Data.ProtoLens.Tag 2, value__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldOptions'EditionDefault'_unknownFields + (\ x__ y__ + -> x__ {_FieldOptions'EditionDefault'_unknownFields = y__}) + defMessage + = FieldOptions'EditionDefault'_constructor + {_FieldOptions'EditionDefault'edition = Prelude.Nothing, + _FieldOptions'EditionDefault'value = Prelude.Nothing, + _FieldOptions'EditionDefault'_unknownFields = []} + parseMessage + = let + loop :: + FieldOptions'EditionDefault + -> Data.ProtoLens.Encoding.Bytes.Parser FieldOptions'EditionDefault + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"edition") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "value" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "EditionDefault" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'edition") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'value") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData FieldOptions'EditionDefault where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FieldOptions'EditionDefault'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FieldOptions'EditionDefault'edition x__) + (Control.DeepSeq.deepseq + (_FieldOptions'EditionDefault'value x__) ())) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.editionIntroduced' @:: Lens' FieldOptions'FeatureSupport Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'editionIntroduced' @:: Lens' FieldOptions'FeatureSupport (Prelude.Maybe Edition)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.editionDeprecated' @:: Lens' FieldOptions'FeatureSupport Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'editionDeprecated' @:: Lens' FieldOptions'FeatureSupport (Prelude.Maybe Edition)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecationWarning' @:: Lens' FieldOptions'FeatureSupport Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecationWarning' @:: Lens' FieldOptions'FeatureSupport (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.editionRemoved' @:: Lens' FieldOptions'FeatureSupport Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'editionRemoved' @:: Lens' FieldOptions'FeatureSupport (Prelude.Maybe Edition)@ -} +data FieldOptions'FeatureSupport + = FieldOptions'FeatureSupport'_constructor {_FieldOptions'FeatureSupport'editionIntroduced :: !(Prelude.Maybe Edition), + _FieldOptions'FeatureSupport'editionDeprecated :: !(Prelude.Maybe Edition), + _FieldOptions'FeatureSupport'deprecationWarning :: !(Prelude.Maybe Data.Text.Text), + _FieldOptions'FeatureSupport'editionRemoved :: !(Prelude.Maybe Edition), + _FieldOptions'FeatureSupport'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FieldOptions'FeatureSupport where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "editionIntroduced" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionIntroduced + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionIntroduced = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "maybe'editionIntroduced" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionIntroduced + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionIntroduced = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "editionDeprecated" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionDeprecated + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionDeprecated = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "maybe'editionDeprecated" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionDeprecated + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionDeprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "deprecationWarning" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'deprecationWarning + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'deprecationWarning = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "maybe'deprecationWarning" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'deprecationWarning + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'deprecationWarning = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "editionRemoved" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionRemoved + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionRemoved = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FieldOptions'FeatureSupport "maybe'editionRemoved" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'editionRemoved + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'editionRemoved = y__})) + Prelude.id +instance Data.ProtoLens.Message FieldOptions'FeatureSupport where + messageName _ + = Data.Text.pack "google.protobuf.FieldOptions.FeatureSupport" + packedMessageDescriptor _ + = "\n\ + \\SOFeatureSupport\DC2G\n\ + \\DC2edition_introduced\CAN\SOH \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionIntroduced\DC2G\n\ + \\DC2edition_deprecated\CAN\STX \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionDeprecated\DC2/\n\ + \\DC3deprecation_warning\CAN\ETX \SOH(\tR\DC2deprecationWarning\DC2A\n\ + \\SIedition_removed\CAN\EOT \SOH(\SO2\CAN.google.protobuf.EditionR\SOeditionRemoved" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + editionIntroduced__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition_introduced" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'editionIntroduced")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'FeatureSupport + editionDeprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition_deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'editionDeprecated")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'FeatureSupport + deprecationWarning__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecation_warning" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'deprecationWarning")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'FeatureSupport + editionRemoved__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition_removed" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'editionRemoved")) :: + Data.ProtoLens.FieldDescriptor FieldOptions'FeatureSupport + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, editionIntroduced__field_descriptor), + (Data.ProtoLens.Tag 2, editionDeprecated__field_descriptor), + (Data.ProtoLens.Tag 3, deprecationWarning__field_descriptor), + (Data.ProtoLens.Tag 4, editionRemoved__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldOptions'FeatureSupport'_unknownFields + (\ x__ y__ + -> x__ {_FieldOptions'FeatureSupport'_unknownFields = y__}) + defMessage + = FieldOptions'FeatureSupport'_constructor + {_FieldOptions'FeatureSupport'editionIntroduced = Prelude.Nothing, + _FieldOptions'FeatureSupport'editionDeprecated = Prelude.Nothing, + _FieldOptions'FeatureSupport'deprecationWarning = Prelude.Nothing, + _FieldOptions'FeatureSupport'editionRemoved = Prelude.Nothing, + _FieldOptions'FeatureSupport'_unknownFields = []} + parseMessage + = let + loop :: + FieldOptions'FeatureSupport + -> Data.ProtoLens.Encoding.Bytes.Parser FieldOptions'FeatureSupport + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition_introduced" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"editionIntroduced") y x) + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition_deprecated" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"editionDeprecated") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "deprecation_warning" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"deprecationWarning") y x) + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition_removed" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"editionRemoved") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "FeatureSupport" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'editionIntroduced") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'editionDeprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecationWarning") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'editionRemoved") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))) +instance Control.DeepSeq.NFData FieldOptions'FeatureSupport where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FieldOptions'FeatureSupport'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FieldOptions'FeatureSupport'editionIntroduced x__) + (Control.DeepSeq.deepseq + (_FieldOptions'FeatureSupport'editionDeprecated x__) + (Control.DeepSeq.deepseq + (_FieldOptions'FeatureSupport'deprecationWarning x__) + (Control.DeepSeq.deepseq + (_FieldOptions'FeatureSupport'editionRemoved x__) ())))) +data FieldOptions'JSType + = FieldOptions'JS_NORMAL | + FieldOptions'JS_STRING | + FieldOptions'JS_NUMBER + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +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 k + | (Prelude.==) k "JS_NORMAL" = Prelude.Just FieldOptions'JS_NORMAL + | (Prelude.==) k "JS_STRING" = Prelude.Just FieldOptions'JS_STRING + | (Prelude.==) k "JS_NUMBER" = Prelude.Just FieldOptions'JS_NUMBER + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldOptions'JSType where + minBound = FieldOptions'JS_NORMAL + maxBound = FieldOptions'JS_NUMBER +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 Data.ProtoLens.FieldDefault FieldOptions'JSType where + fieldDefault = FieldOptions'JS_NORMAL +instance Control.DeepSeq.NFData FieldOptions'JSType where + rnf x__ = Prelude.seq x__ () +data FieldOptions'OptionRetention + = FieldOptions'RETENTION_UNKNOWN | + FieldOptions'RETENTION_RUNTIME | + FieldOptions'RETENTION_SOURCE + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FieldOptions'OptionRetention where + maybeToEnum 0 = Prelude.Just FieldOptions'RETENTION_UNKNOWN + maybeToEnum 1 = Prelude.Just FieldOptions'RETENTION_RUNTIME + maybeToEnum 2 = Prelude.Just FieldOptions'RETENTION_SOURCE + maybeToEnum _ = Prelude.Nothing + showEnum FieldOptions'RETENTION_UNKNOWN = "RETENTION_UNKNOWN" + showEnum FieldOptions'RETENTION_RUNTIME = "RETENTION_RUNTIME" + showEnum FieldOptions'RETENTION_SOURCE = "RETENTION_SOURCE" + readEnum k + | (Prelude.==) k "RETENTION_UNKNOWN" + = Prelude.Just FieldOptions'RETENTION_UNKNOWN + | (Prelude.==) k "RETENTION_RUNTIME" + = Prelude.Just FieldOptions'RETENTION_RUNTIME + | (Prelude.==) k "RETENTION_SOURCE" + = Prelude.Just FieldOptions'RETENTION_SOURCE + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldOptions'OptionRetention where + minBound = FieldOptions'RETENTION_UNKNOWN + maxBound = FieldOptions'RETENTION_SOURCE +instance Prelude.Enum FieldOptions'OptionRetention where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum OptionRetention: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldOptions'RETENTION_UNKNOWN = 0 + fromEnum FieldOptions'RETENTION_RUNTIME = 1 + fromEnum FieldOptions'RETENTION_SOURCE = 2 + succ FieldOptions'RETENTION_SOURCE + = Prelude.error + "FieldOptions'OptionRetention.succ: bad argument FieldOptions'RETENTION_SOURCE. This value would be out of bounds." + succ FieldOptions'RETENTION_UNKNOWN + = FieldOptions'RETENTION_RUNTIME + succ FieldOptions'RETENTION_RUNTIME = FieldOptions'RETENTION_SOURCE + pred FieldOptions'RETENTION_UNKNOWN + = Prelude.error + "FieldOptions'OptionRetention.pred: bad argument FieldOptions'RETENTION_UNKNOWN. This value would be out of bounds." + pred FieldOptions'RETENTION_RUNTIME + = FieldOptions'RETENTION_UNKNOWN + pred FieldOptions'RETENTION_SOURCE = FieldOptions'RETENTION_RUNTIME + 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 Data.ProtoLens.FieldDefault FieldOptions'OptionRetention where + fieldDefault = FieldOptions'RETENTION_UNKNOWN +instance Control.DeepSeq.NFData FieldOptions'OptionRetention where + rnf x__ = Prelude.seq x__ () +data FieldOptions'OptionTargetType + = FieldOptions'TARGET_TYPE_UNKNOWN | + FieldOptions'TARGET_TYPE_FILE | + FieldOptions'TARGET_TYPE_EXTENSION_RANGE | + FieldOptions'TARGET_TYPE_MESSAGE | + FieldOptions'TARGET_TYPE_FIELD | + FieldOptions'TARGET_TYPE_ONEOF | + FieldOptions'TARGET_TYPE_ENUM | + FieldOptions'TARGET_TYPE_ENUM_ENTRY | + FieldOptions'TARGET_TYPE_SERVICE | + FieldOptions'TARGET_TYPE_METHOD + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum FieldOptions'OptionTargetType where + maybeToEnum 0 = Prelude.Just FieldOptions'TARGET_TYPE_UNKNOWN + maybeToEnum 1 = Prelude.Just FieldOptions'TARGET_TYPE_FILE + maybeToEnum 2 + = Prelude.Just FieldOptions'TARGET_TYPE_EXTENSION_RANGE + maybeToEnum 3 = Prelude.Just FieldOptions'TARGET_TYPE_MESSAGE + maybeToEnum 4 = Prelude.Just FieldOptions'TARGET_TYPE_FIELD + maybeToEnum 5 = Prelude.Just FieldOptions'TARGET_TYPE_ONEOF + maybeToEnum 6 = Prelude.Just FieldOptions'TARGET_TYPE_ENUM + maybeToEnum 7 = Prelude.Just FieldOptions'TARGET_TYPE_ENUM_ENTRY + maybeToEnum 8 = Prelude.Just FieldOptions'TARGET_TYPE_SERVICE + maybeToEnum 9 = Prelude.Just FieldOptions'TARGET_TYPE_METHOD + maybeToEnum _ = Prelude.Nothing + showEnum FieldOptions'TARGET_TYPE_UNKNOWN = "TARGET_TYPE_UNKNOWN" + showEnum FieldOptions'TARGET_TYPE_FILE = "TARGET_TYPE_FILE" + showEnum FieldOptions'TARGET_TYPE_EXTENSION_RANGE + = "TARGET_TYPE_EXTENSION_RANGE" + showEnum FieldOptions'TARGET_TYPE_MESSAGE = "TARGET_TYPE_MESSAGE" + showEnum FieldOptions'TARGET_TYPE_FIELD = "TARGET_TYPE_FIELD" + showEnum FieldOptions'TARGET_TYPE_ONEOF = "TARGET_TYPE_ONEOF" + showEnum FieldOptions'TARGET_TYPE_ENUM = "TARGET_TYPE_ENUM" + showEnum FieldOptions'TARGET_TYPE_ENUM_ENTRY + = "TARGET_TYPE_ENUM_ENTRY" + showEnum FieldOptions'TARGET_TYPE_SERVICE = "TARGET_TYPE_SERVICE" + showEnum FieldOptions'TARGET_TYPE_METHOD = "TARGET_TYPE_METHOD" + readEnum k + | (Prelude.==) k "TARGET_TYPE_UNKNOWN" + = Prelude.Just FieldOptions'TARGET_TYPE_UNKNOWN + | (Prelude.==) k "TARGET_TYPE_FILE" + = Prelude.Just FieldOptions'TARGET_TYPE_FILE + | (Prelude.==) k "TARGET_TYPE_EXTENSION_RANGE" + = Prelude.Just FieldOptions'TARGET_TYPE_EXTENSION_RANGE + | (Prelude.==) k "TARGET_TYPE_MESSAGE" + = Prelude.Just FieldOptions'TARGET_TYPE_MESSAGE + | (Prelude.==) k "TARGET_TYPE_FIELD" + = Prelude.Just FieldOptions'TARGET_TYPE_FIELD + | (Prelude.==) k "TARGET_TYPE_ONEOF" + = Prelude.Just FieldOptions'TARGET_TYPE_ONEOF + | (Prelude.==) k "TARGET_TYPE_ENUM" + = Prelude.Just FieldOptions'TARGET_TYPE_ENUM + | (Prelude.==) k "TARGET_TYPE_ENUM_ENTRY" + = Prelude.Just FieldOptions'TARGET_TYPE_ENUM_ENTRY + | (Prelude.==) k "TARGET_TYPE_SERVICE" + = Prelude.Just FieldOptions'TARGET_TYPE_SERVICE + | (Prelude.==) k "TARGET_TYPE_METHOD" + = Prelude.Just FieldOptions'TARGET_TYPE_METHOD + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FieldOptions'OptionTargetType where + minBound = FieldOptions'TARGET_TYPE_UNKNOWN + maxBound = FieldOptions'TARGET_TYPE_METHOD +instance Prelude.Enum FieldOptions'OptionTargetType where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum OptionTargetType: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum FieldOptions'TARGET_TYPE_UNKNOWN = 0 + fromEnum FieldOptions'TARGET_TYPE_FILE = 1 + fromEnum FieldOptions'TARGET_TYPE_EXTENSION_RANGE = 2 + fromEnum FieldOptions'TARGET_TYPE_MESSAGE = 3 + fromEnum FieldOptions'TARGET_TYPE_FIELD = 4 + fromEnum FieldOptions'TARGET_TYPE_ONEOF = 5 + fromEnum FieldOptions'TARGET_TYPE_ENUM = 6 + fromEnum FieldOptions'TARGET_TYPE_ENUM_ENTRY = 7 + fromEnum FieldOptions'TARGET_TYPE_SERVICE = 8 + fromEnum FieldOptions'TARGET_TYPE_METHOD = 9 + succ FieldOptions'TARGET_TYPE_METHOD + = Prelude.error + "FieldOptions'OptionTargetType.succ: bad argument FieldOptions'TARGET_TYPE_METHOD. This value would be out of bounds." + succ FieldOptions'TARGET_TYPE_UNKNOWN + = FieldOptions'TARGET_TYPE_FILE + succ FieldOptions'TARGET_TYPE_FILE + = FieldOptions'TARGET_TYPE_EXTENSION_RANGE + succ FieldOptions'TARGET_TYPE_EXTENSION_RANGE + = FieldOptions'TARGET_TYPE_MESSAGE + succ FieldOptions'TARGET_TYPE_MESSAGE + = FieldOptions'TARGET_TYPE_FIELD + succ FieldOptions'TARGET_TYPE_FIELD + = FieldOptions'TARGET_TYPE_ONEOF + succ FieldOptions'TARGET_TYPE_ONEOF = FieldOptions'TARGET_TYPE_ENUM + succ FieldOptions'TARGET_TYPE_ENUM + = FieldOptions'TARGET_TYPE_ENUM_ENTRY + succ FieldOptions'TARGET_TYPE_ENUM_ENTRY + = FieldOptions'TARGET_TYPE_SERVICE + succ FieldOptions'TARGET_TYPE_SERVICE + = FieldOptions'TARGET_TYPE_METHOD + pred FieldOptions'TARGET_TYPE_UNKNOWN + = Prelude.error + "FieldOptions'OptionTargetType.pred: bad argument FieldOptions'TARGET_TYPE_UNKNOWN. This value would be out of bounds." + pred FieldOptions'TARGET_TYPE_FILE + = FieldOptions'TARGET_TYPE_UNKNOWN + pred FieldOptions'TARGET_TYPE_EXTENSION_RANGE + = FieldOptions'TARGET_TYPE_FILE + pred FieldOptions'TARGET_TYPE_MESSAGE + = FieldOptions'TARGET_TYPE_EXTENSION_RANGE + pred FieldOptions'TARGET_TYPE_FIELD + = FieldOptions'TARGET_TYPE_MESSAGE + pred FieldOptions'TARGET_TYPE_ONEOF + = FieldOptions'TARGET_TYPE_FIELD + pred FieldOptions'TARGET_TYPE_ENUM = FieldOptions'TARGET_TYPE_ONEOF + pred FieldOptions'TARGET_TYPE_ENUM_ENTRY + = FieldOptions'TARGET_TYPE_ENUM + pred FieldOptions'TARGET_TYPE_SERVICE + = FieldOptions'TARGET_TYPE_ENUM_ENTRY + pred FieldOptions'TARGET_TYPE_METHOD + = FieldOptions'TARGET_TYPE_SERVICE + 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 Data.ProtoLens.FieldDefault FieldOptions'OptionTargetType where + fieldDefault = FieldOptions'TARGET_TYPE_UNKNOWN +instance Control.DeepSeq.NFData FieldOptions'OptionTargetType where + rnf x__ = Prelude.seq x__ () +{- | 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.vec'dependency' @:: Lens' FileDescriptorProto (Data.Vector.Vector Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.publicDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'publicDependency' @:: Lens' FileDescriptorProto (Data.Vector.Unboxed.Vector Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.weakDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'weakDependency' @:: Lens' FileDescriptorProto (Data.Vector.Unboxed.Vector Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.messageType' @:: Lens' FileDescriptorProto [DescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'messageType' @:: Lens' FileDescriptorProto (Data.Vector.Vector DescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' FileDescriptorProto [EnumDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'enumType' @:: Lens' FileDescriptorProto (Data.Vector.Vector EnumDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.service' @:: Lens' FileDescriptorProto [ServiceDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'service' @:: Lens' FileDescriptorProto (Data.Vector.Vector ServiceDescriptorProto)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' FileDescriptorProto [FieldDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extension' @:: Lens' FileDescriptorProto (Data.Vector.Vector 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)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.edition' @:: Lens' FileDescriptorProto Edition@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'edition' @:: Lens' FileDescriptorProto (Prelude.Maybe Edition)@ -} +data FileDescriptorProto + = FileDescriptorProto'_constructor {_FileDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'package :: !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'dependency :: !(Data.Vector.Vector Data.Text.Text), + _FileDescriptorProto'publicDependency :: !(Data.Vector.Unboxed.Vector Data.Int.Int32), + _FileDescriptorProto'weakDependency :: !(Data.Vector.Unboxed.Vector Data.Int.Int32), + _FileDescriptorProto'messageType :: !(Data.Vector.Vector DescriptorProto), + _FileDescriptorProto'enumType :: !(Data.Vector.Vector EnumDescriptorProto), + _FileDescriptorProto'service :: !(Data.Vector.Vector ServiceDescriptorProto), + _FileDescriptorProto'extension :: !(Data.Vector.Vector FieldDescriptorProto), + _FileDescriptorProto'options :: !(Prelude.Maybe FileOptions), + _FileDescriptorProto'sourceCodeInfo :: !(Prelude.Maybe SourceCodeInfo), + _FileDescriptorProto'syntax :: !(Prelude.Maybe Data.Text.Text), + _FileDescriptorProto'edition :: !(Prelude.Maybe Edition), + _FileDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FileDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'name + (\ x__ y__ -> x__ {_FileDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'name + (\ x__ y__ -> x__ {_FileDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "package" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'package + (\ x__ y__ -> x__ {_FileDescriptorProto'package = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'package" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'package + (\ x__ y__ -> x__ {_FileDescriptorProto'package = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "dependency" [Data.Text.Text] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'dependency + (\ x__ y__ -> x__ {_FileDescriptorProto'dependency = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'dependency" (Data.Vector.Vector Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'dependency + (\ x__ y__ -> x__ {_FileDescriptorProto'dependency = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "publicDependency" [Data.Int.Int32] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'publicDependency + (\ x__ y__ -> x__ {_FileDescriptorProto'publicDependency = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'publicDependency" (Data.Vector.Unboxed.Vector Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'publicDependency + (\ x__ y__ -> x__ {_FileDescriptorProto'publicDependency = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "weakDependency" [Data.Int.Int32] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'weakDependency + (\ x__ y__ -> x__ {_FileDescriptorProto'weakDependency = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'weakDependency" (Data.Vector.Unboxed.Vector Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'weakDependency + (\ x__ y__ -> x__ {_FileDescriptorProto'weakDependency = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "messageType" [DescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'messageType + (\ x__ y__ -> x__ {_FileDescriptorProto'messageType = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'messageType" (Data.Vector.Vector DescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'messageType + (\ x__ y__ -> x__ {_FileDescriptorProto'messageType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "enumType" [EnumDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'enumType + (\ x__ y__ -> x__ {_FileDescriptorProto'enumType = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'enumType" (Data.Vector.Vector EnumDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'enumType + (\ x__ y__ -> x__ {_FileDescriptorProto'enumType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "service" [ServiceDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'service + (\ x__ y__ -> x__ {_FileDescriptorProto'service = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'service" (Data.Vector.Vector ServiceDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'service + (\ x__ y__ -> x__ {_FileDescriptorProto'service = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "extension" [FieldDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'extension + (\ x__ y__ -> x__ {_FileDescriptorProto'extension = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'extension" (Data.Vector.Vector FieldDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'extension + (\ x__ y__ -> x__ {_FileDescriptorProto'extension = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "options" FileOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'options + (\ x__ y__ -> x__ {_FileDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'options" (Prelude.Maybe FileOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'options + (\ x__ y__ -> x__ {_FileDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "sourceCodeInfo" SourceCodeInfo where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'sourceCodeInfo + (\ x__ y__ -> x__ {_FileDescriptorProto'sourceCodeInfo = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'sourceCodeInfo" (Prelude.Maybe SourceCodeInfo) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'sourceCodeInfo + (\ x__ y__ -> x__ {_FileDescriptorProto'sourceCodeInfo = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "syntax" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'syntax + (\ x__ y__ -> x__ {_FileDescriptorProto'syntax = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'syntax" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'syntax + (\ x__ y__ -> x__ {_FileDescriptorProto'syntax = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileDescriptorProto "edition" Edition where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'edition + (\ x__ y__ -> x__ {_FileDescriptorProto'edition = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'edition" (Prelude.Maybe Edition) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorProto'edition + (\ x__ y__ -> x__ {_FileDescriptorProto'edition = y__})) + Prelude.id +instance Data.ProtoLens.Message FileDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FileDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\DC3FileDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\CAN\n\ + \\apackage\CAN\STX \SOH(\tR\apackage\DC2\RS\n\ + \\n\ + \dependency\CAN\ETX \ETX(\tR\n\ + \dependency\DC2+\n\ + \\DC1public_dependency\CAN\n\ + \ \ETX(\ENQR\DLEpublicDependency\DC2'\n\ + \\SIweak_dependency\CAN\v \ETX(\ENQR\SOweakDependency\DC2C\n\ + \\fmessage_type\CAN\EOT \ETX(\v2 .google.protobuf.DescriptorProtoR\vmessageType\DC2A\n\ + \\tenum_type\CAN\ENQ \ETX(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\DC2A\n\ + \\aservice\CAN\ACK \ETX(\v2'.google.protobuf.ServiceDescriptorProtoR\aservice\DC2C\n\ + \\textension\CAN\a \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\textension\DC26\n\ + \\aoptions\CAN\b \SOH(\v2\FS.google.protobuf.FileOptionsR\aoptions\DC2I\n\ + \\DLEsource_code_info\CAN\t \SOH(\v2\US.google.protobuf.SourceCodeInfoR\SOsourceCodeInfo\DC2\SYN\n\ + \\ACKsyntax\CAN\f \SOH(\tR\ACKsyntax\DC22\n\ + \\aedition\CAN\SO \SOH(\SO2\CAN.google.protobuf.EditionR\aedition" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'syntax")) :: + Data.ProtoLens.FieldDescriptor FileDescriptorProto + edition__field_descriptor + = Data.ProtoLens.FieldDescriptor + "edition" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor Edition) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'edition")) :: + 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), + (Data.ProtoLens.Tag 14, edition__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FileDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_FileDescriptorProto'_unknownFields = y__}) + defMessage + = FileDescriptorProto'_constructor + {_FileDescriptorProto'name = Prelude.Nothing, + _FileDescriptorProto'package = Prelude.Nothing, + _FileDescriptorProto'dependency = Data.Vector.Generic.empty, + _FileDescriptorProto'publicDependency = Data.Vector.Generic.empty, + _FileDescriptorProto'weakDependency = Data.Vector.Generic.empty, + _FileDescriptorProto'messageType = Data.Vector.Generic.empty, + _FileDescriptorProto'enumType = Data.Vector.Generic.empty, + _FileDescriptorProto'service = Data.Vector.Generic.empty, + _FileDescriptorProto'extension = Data.Vector.Generic.empty, + _FileDescriptorProto'options = Prelude.Nothing, + _FileDescriptorProto'sourceCodeInfo = Prelude.Nothing, + _FileDescriptorProto'syntax = Prelude.Nothing, + _FileDescriptorProto'edition = Prelude.Nothing, + _FileDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + FileDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32 + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld ServiceDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32 + -> Data.ProtoLens.Encoding.Bytes.Parser FileDescriptorProto + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'dependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'dependency) + frozen'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'enumType) + frozen'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'extension) + frozen'messageType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'messageType) + frozen'publicDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'publicDependency) + frozen'service <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'service) + frozen'weakDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'weakDependency) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'dependency") + frozen'dependency + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'enumType") + frozen'enumType + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'extension") + frozen'extension + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'messageType") + frozen'messageType + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'publicDependency") + frozen'publicDependency + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'service") + frozen'service + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'weakDependency") + frozen'weakDependency + x)))))))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"package") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 26 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "dependency" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'dependency y) + loop + x + v + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 80 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "public_dependency" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'publicDependency y) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + v + mutable'service + mutable'weakDependency + 82 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "public_dependency" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'publicDependency) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + y + mutable'service + mutable'weakDependency + 88 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "weak_dependency" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'weakDependency y) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + v + 90 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "weak_dependency" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'weakDependency) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + y + 34 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "message_type" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'messageType y) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + v + mutable'publicDependency + mutable'service + mutable'weakDependency + 42 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "enum_type" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'enumType y) + loop + x + mutable'dependency + v + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 50 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "service" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'service y) + loop + x + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + v + mutable'weakDependency + 58 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "extension" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'extension y) + loop + x + mutable'dependency + mutable'enumType + v + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 66 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 74 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "source_code_info" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"sourceCodeInfo") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 98 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "syntax" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"syntax") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + 112 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "edition" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"edition") y x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'dependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'messageType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'publicDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'service <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'weakDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'dependency + mutable'enumType + mutable'extension + mutable'messageType + mutable'publicDependency + mutable'service + mutable'weakDependency) + "FileDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'package") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'dependency") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 80) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'publicDependency") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 88) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'weakDependency") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'messageType") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 42) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'enumType") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 50) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'service") _x)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 58) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'extension") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 66) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'sourceCodeInfo") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 74) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'syntax") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 98) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'edition") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 112) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view + Data.ProtoLens.unknownFields _x)))))))))))))) +instance Control.DeepSeq.NFData FileDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FileDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'package x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'dependency x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'publicDependency x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'weakDependency x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'messageType x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'enumType x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'service x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'extension x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'options x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'sourceCodeInfo x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'syntax x__) + (Control.DeepSeq.deepseq + (_FileDescriptorProto'edition x__) + ()))))))))))))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.file' @:: Lens' FileDescriptorSet [FileDescriptorProto]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'file' @:: Lens' FileDescriptorSet (Data.Vector.Vector FileDescriptorProto)@ -} +data FileDescriptorSet + = FileDescriptorSet'_constructor {_FileDescriptorSet'file :: !(Data.Vector.Vector FileDescriptorProto), + _FileDescriptorSet'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FileDescriptorSet where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FileDescriptorSet "file" [FileDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorSet'file + (\ x__ y__ -> x__ {_FileDescriptorSet'file = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileDescriptorSet "vec'file" (Data.Vector.Vector FileDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileDescriptorSet'file + (\ x__ y__ -> x__ {_FileDescriptorSet'file = y__})) + Prelude.id +instance Data.ProtoLens.Message FileDescriptorSet where + messageName _ = Data.Text.pack "google.protobuf.FileDescriptorSet" + packedMessageDescriptor _ + = "\n\ + \\DC1FileDescriptorSet\DC28\n\ + \\EOTfile\CAN\SOH \ETX(\v2$.google.protobuf.FileDescriptorProtoR\EOTfile" + packedFileDescriptor _ = packedFileDescriptor + 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 (Data.ProtoLens.Field.field @"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__}) + defMessage + = FileDescriptorSet'_constructor + {_FileDescriptorSet'file = Data.Vector.Generic.empty, + _FileDescriptorSet'_unknownFields = []} + parseMessage + = let + loop :: + FileDescriptorSet + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FileDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser FileDescriptorSet + loop x mutable'file + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'file) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'file") frozen'file x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "file" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'file y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'file + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'file) + "FileDescriptorSet" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'file") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)) +instance Control.DeepSeq.NFData FileDescriptorSet where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FileDescriptorSet'_unknownFields x__) + (Control.DeepSeq.deepseq (_FileDescriptorSet'file x__) ()) +{- | 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.swiftPrefix' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'swiftPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.phpClassPrefix' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpClassPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.phpNamespace' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.phpMetadataNamespace' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpMetadataNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.rubyPackage' @:: Lens' FileOptions Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'rubyPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' FileOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' FileOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FileOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' FileOptions (Data.Vector.Vector UninterpretedOption)@ -} +data FileOptions + = FileOptions'_constructor {_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'swiftPrefix :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'phpClassPrefix :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'phpNamespace :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'phpMetadataNamespace :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'rubyPackage :: !(Prelude.Maybe Data.Text.Text), + _FileOptions'features :: !(Prelude.Maybe FeatureSet), + _FileOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _FileOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show FileOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField FileOptions "javaPackage" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaPackage + (\ x__ y__ -> x__ {_FileOptions'javaPackage = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaPackage" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaPackage + (\ x__ y__ -> x__ {_FileOptions'javaPackage = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "javaOuterClassname" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaOuterClassname + (\ x__ y__ -> x__ {_FileOptions'javaOuterClassname = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaOuterClassname" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaOuterClassname + (\ x__ y__ -> x__ {_FileOptions'javaOuterClassname = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "javaMultipleFiles" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaMultipleFiles + (\ x__ y__ -> x__ {_FileOptions'javaMultipleFiles = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaMultipleFiles" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaMultipleFiles + (\ x__ y__ -> x__ {_FileOptions'javaMultipleFiles = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "javaGenerateEqualsAndHash" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaGenerateEqualsAndHash + (\ x__ y__ -> x__ {_FileOptions'javaGenerateEqualsAndHash = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaGenerateEqualsAndHash" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaGenerateEqualsAndHash + (\ x__ y__ -> x__ {_FileOptions'javaGenerateEqualsAndHash = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "javaStringCheckUtf8" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaStringCheckUtf8 + (\ x__ y__ -> x__ {_FileOptions'javaStringCheckUtf8 = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaStringCheckUtf8" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaStringCheckUtf8 + (\ x__ y__ -> x__ {_FileOptions'javaStringCheckUtf8 = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "optimizeFor" FileOptions'OptimizeMode where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'optimizeFor + (\ x__ y__ -> x__ {_FileOptions'optimizeFor = y__})) + (Data.ProtoLens.maybeLens FileOptions'SPEED) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'optimizeFor" (Prelude.Maybe FileOptions'OptimizeMode) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'optimizeFor + (\ x__ y__ -> x__ {_FileOptions'optimizeFor = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "goPackage" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'goPackage + (\ x__ y__ -> x__ {_FileOptions'goPackage = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'goPackage" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'goPackage + (\ x__ y__ -> x__ {_FileOptions'goPackage = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "ccGenericServices" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'ccGenericServices + (\ x__ y__ -> x__ {_FileOptions'ccGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'ccGenericServices" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'ccGenericServices + (\ x__ y__ -> x__ {_FileOptions'ccGenericServices = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "javaGenericServices" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaGenericServices + (\ x__ y__ -> x__ {_FileOptions'javaGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaGenericServices" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'javaGenericServices + (\ x__ y__ -> x__ {_FileOptions'javaGenericServices = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "pyGenericServices" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'pyGenericServices + (\ x__ y__ -> x__ {_FileOptions'pyGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'pyGenericServices" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'pyGenericServices + (\ x__ y__ -> x__ {_FileOptions'pyGenericServices = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'deprecated + (\ x__ y__ -> x__ {_FileOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'deprecated + (\ x__ y__ -> x__ {_FileOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "ccEnableArenas" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'ccEnableArenas + (\ x__ y__ -> x__ {_FileOptions'ccEnableArenas = y__})) + (Data.ProtoLens.maybeLens Prelude.True) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'ccEnableArenas" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'ccEnableArenas + (\ x__ y__ -> x__ {_FileOptions'ccEnableArenas = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "objcClassPrefix" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'objcClassPrefix + (\ x__ y__ -> x__ {_FileOptions'objcClassPrefix = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'objcClassPrefix" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'objcClassPrefix + (\ x__ y__ -> x__ {_FileOptions'objcClassPrefix = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "csharpNamespace" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'csharpNamespace + (\ x__ y__ -> x__ {_FileOptions'csharpNamespace = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'csharpNamespace" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'csharpNamespace + (\ x__ y__ -> x__ {_FileOptions'csharpNamespace = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "swiftPrefix" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'swiftPrefix + (\ x__ y__ -> x__ {_FileOptions'swiftPrefix = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'swiftPrefix" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'swiftPrefix + (\ x__ y__ -> x__ {_FileOptions'swiftPrefix = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "phpClassPrefix" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpClassPrefix + (\ x__ y__ -> x__ {_FileOptions'phpClassPrefix = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpClassPrefix" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpClassPrefix + (\ x__ y__ -> x__ {_FileOptions'phpClassPrefix = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "phpNamespace" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpNamespace + (\ x__ y__ -> x__ {_FileOptions'phpNamespace = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpNamespace" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpNamespace + (\ x__ y__ -> x__ {_FileOptions'phpNamespace = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "phpMetadataNamespace" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpMetadataNamespace + (\ x__ y__ -> x__ {_FileOptions'phpMetadataNamespace = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpMetadataNamespace" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpMetadataNamespace + (\ x__ y__ -> x__ {_FileOptions'phpMetadataNamespace = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "rubyPackage" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'rubyPackage + (\ x__ y__ -> x__ {_FileOptions'rubyPackage = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'rubyPackage" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'rubyPackage + (\ x__ y__ -> x__ {_FileOptions'rubyPackage = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'features + (\ x__ y__ -> x__ {_FileOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'features + (\ x__ y__ -> x__ {_FileOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField FileOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'uninterpretedOption + (\ x__ y__ -> x__ {_FileOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField FileOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'uninterpretedOption + (\ x__ y__ -> x__ {_FileOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message FileOptions where + messageName _ = Data.Text.pack "google.protobuf.FileOptions" + packedMessageDescriptor _ + = "\n\ + \\vFileOptions\DC2!\n\ + \\fjava_package\CAN\SOH \SOH(\tR\vjavaPackage\DC20\n\ + \\DC4java_outer_classname\CAN\b \SOH(\tR\DC2javaOuterClassname\DC25\n\ + \\DC3java_multiple_files\CAN\n\ + \ \SOH(\b:\ENQfalseR\DC1javaMultipleFiles\DC2D\n\ + \\GSjava_generate_equals_and_hash\CAN\DC4 \SOH(\bR\EMjavaGenerateEqualsAndHashB\STX\CAN\SOH\DC2:\n\ + \\SYNjava_string_check_utf8\CAN\ESC \SOH(\b:\ENQfalseR\DC3javaStringCheckUtf8\DC2S\n\ + \\foptimize_for\CAN\t \SOH(\SO2).google.protobuf.FileOptions.OptimizeMode:\ENQSPEEDR\voptimizeFor\DC2\GS\n\ + \\n\ + \go_package\CAN\v \SOH(\tR\tgoPackage\DC25\n\ + \\DC3cc_generic_services\CAN\DLE \SOH(\b:\ENQfalseR\DC1ccGenericServices\DC29\n\ + \\NAKjava_generic_services\CAN\DC1 \SOH(\b:\ENQfalseR\DC3javaGenericServices\DC25\n\ + \\DC3py_generic_services\CAN\DC2 \SOH(\b:\ENQfalseR\DC1pyGenericServices\DC2%\n\ + \\n\ + \deprecated\CAN\ETB \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2.\n\ + \\DLEcc_enable_arenas\CAN\US \SOH(\b:\EOTtrueR\SOccEnableArenas\DC2*\n\ + \\DC1objc_class_prefix\CAN$ \SOH(\tR\SIobjcClassPrefix\DC2)\n\ + \\DLEcsharp_namespace\CAN% \SOH(\tR\SIcsharpNamespace\DC2!\n\ + \\fswift_prefix\CAN' \SOH(\tR\vswiftPrefix\DC2(\n\ + \\DLEphp_class_prefix\CAN( \SOH(\tR\SOphpClassPrefix\DC2#\n\ + \\rphp_namespace\CAN) \SOH(\tR\fphpNamespace\DC24\n\ + \\SYNphp_metadata_namespace\CAN, \SOH(\tR\DC4phpMetadataNamespace\DC2!\n\ + \\fruby_package\CAN- \SOH(\tR\vrubyPackage\DC27\n\ + \\bfeatures\CAN2 \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\":\n\ + \\fOptimizeMode\DC2\t\n\ + \\ENQSPEED\DLE\SOH\DC2\r\n\ + \\tCODE_SIZE\DLE\STX\DC2\DLE\n\ + \\fLITE_RUNTIME\DLE\ETX*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b*\DLE+J\EOT\b&\DLE'R\DC4php_generic_services" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'csharpNamespace")) :: + Data.ProtoLens.FieldDescriptor FileOptions + swiftPrefix__field_descriptor + = Data.ProtoLens.FieldDescriptor + "swift_prefix" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'swiftPrefix")) :: + Data.ProtoLens.FieldDescriptor FileOptions + phpClassPrefix__field_descriptor + = Data.ProtoLens.FieldDescriptor + "php_class_prefix" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'phpClassPrefix")) :: + Data.ProtoLens.FieldDescriptor FileOptions + phpNamespace__field_descriptor + = Data.ProtoLens.FieldDescriptor + "php_namespace" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'phpNamespace")) :: + Data.ProtoLens.FieldDescriptor FileOptions + phpMetadataNamespace__field_descriptor + = Data.ProtoLens.FieldDescriptor + "php_metadata_namespace" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'phpMetadataNamespace")) :: + Data.ProtoLens.FieldDescriptor FileOptions + rubyPackage__field_descriptor + = Data.ProtoLens.FieldDescriptor + "ruby_package" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'rubyPackage")) :: + Data.ProtoLens.FieldDescriptor FileOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + 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 + (Data.ProtoLens.Field.field @"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 39, swiftPrefix__field_descriptor), + (Data.ProtoLens.Tag 40, phpClassPrefix__field_descriptor), + (Data.ProtoLens.Tag 41, phpNamespace__field_descriptor), + (Data.ProtoLens.Tag 44, phpMetadataNamespace__field_descriptor), + (Data.ProtoLens.Tag 45, rubyPackage__field_descriptor), + (Data.ProtoLens.Tag 50, features__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FileOptions'_unknownFields + (\ x__ y__ -> x__ {_FileOptions'_unknownFields = y__}) + defMessage + = FileOptions'_constructor + {_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'swiftPrefix = Prelude.Nothing, + _FileOptions'phpClassPrefix = Prelude.Nothing, + _FileOptions'phpNamespace = Prelude.Nothing, + _FileOptions'phpMetadataNamespace = Prelude.Nothing, + _FileOptions'rubyPackage = Prelude.Nothing, + _FileOptions'features = Prelude.Nothing, + _FileOptions'uninterpretedOption = Data.Vector.Generic.empty, + _FileOptions'_unknownFields = []} + parseMessage + = let + loop :: + FileOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser FileOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "java_package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"javaPackage") y x) + mutable'uninterpretedOption + 66 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "java_outer_classname" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"javaOuterClassname") y x) + mutable'uninterpretedOption + 80 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "java_multiple_files" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"javaMultipleFiles") y x) + mutable'uninterpretedOption + 160 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "java_generate_equals_and_hash" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"javaGenerateEqualsAndHash") y x) + mutable'uninterpretedOption + 216 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "java_string_check_utf8" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"javaStringCheckUtf8") y x) + mutable'uninterpretedOption + 72 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "optimize_for" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"optimizeFor") y x) + mutable'uninterpretedOption + 90 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "go_package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"goPackage") y x) + mutable'uninterpretedOption + 128 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "cc_generic_services" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"ccGenericServices") y x) + mutable'uninterpretedOption + 136 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "java_generic_services" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"javaGenericServices") y x) + mutable'uninterpretedOption + 144 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "py_generic_services" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"pyGenericServices") y x) + mutable'uninterpretedOption + 184 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 248 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "cc_enable_arenas" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"ccEnableArenas") y x) + mutable'uninterpretedOption + 290 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "objc_class_prefix" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"objcClassPrefix") y x) + mutable'uninterpretedOption + 298 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "csharp_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"csharpNamespace") y x) + mutable'uninterpretedOption + 314 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "swift_prefix" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"swiftPrefix") y x) + mutable'uninterpretedOption + 322 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "php_class_prefix" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpClassPrefix") y x) + mutable'uninterpretedOption + 330 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "php_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpNamespace") y x) + mutable'uninterpretedOption + 354 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "php_metadata_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpMetadataNamespace") y x) + mutable'uninterpretedOption + 362 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "ruby_package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"rubyPackage") y x) + mutable'uninterpretedOption + 402 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "FileOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'javaPackage") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'javaOuterClassname") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 66) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'javaMultipleFiles") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 80) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'javaGenerateEqualsAndHash") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 160) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'javaStringCheckUtf8") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 216) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'optimizeFor") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 72) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'goPackage") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 90) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'ccGenericServices") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 128) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'javaGenericServices") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 136) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'pyGenericServices") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 144) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 184) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'ccEnableArenas") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 248) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'objcClassPrefix") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 290) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'csharpNamespace") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 298) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'swiftPrefix") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 314) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'phpClassPrefix") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 322) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'phpNamespace") + _x + of + Prelude.Nothing + -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 330) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'phpMetadataNamespace") + _x + of + Prelude.Nothing + -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 354) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'rubyPackage") + _x + of + Prelude.Nothing + -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 362) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'features") + _x + of + Prelude.Nothing + -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 402) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length + bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes + bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field + @"vec'uninterpretedOption") + _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view + Data.ProtoLens.unknownFields + _x)))))))))))))))))))))) +instance Control.DeepSeq.NFData FileOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_FileOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaPackage x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaOuterClassname x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaMultipleFiles x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaGenerateEqualsAndHash x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaStringCheckUtf8 x__) + (Control.DeepSeq.deepseq + (_FileOptions'optimizeFor x__) + (Control.DeepSeq.deepseq + (_FileOptions'goPackage x__) + (Control.DeepSeq.deepseq + (_FileOptions'ccGenericServices x__) + (Control.DeepSeq.deepseq + (_FileOptions'javaGenericServices x__) + (Control.DeepSeq.deepseq + (_FileOptions'pyGenericServices x__) + (Control.DeepSeq.deepseq + (_FileOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_FileOptions'ccEnableArenas x__) + (Control.DeepSeq.deepseq + (_FileOptions'objcClassPrefix x__) + (Control.DeepSeq.deepseq + (_FileOptions'csharpNamespace x__) + (Control.DeepSeq.deepseq + (_FileOptions'swiftPrefix x__) + (Control.DeepSeq.deepseq + (_FileOptions'phpClassPrefix x__) + (Control.DeepSeq.deepseq + (_FileOptions'phpNamespace x__) + (Control.DeepSeq.deepseq + (_FileOptions'phpMetadataNamespace + x__) + (Control.DeepSeq.deepseq + (_FileOptions'rubyPackage x__) + (Control.DeepSeq.deepseq + (_FileOptions'features x__) + (Control.DeepSeq.deepseq + (_FileOptions'uninterpretedOption + x__) + ()))))))))))))))))))))) +data FileOptions'OptimizeMode + = FileOptions'SPEED | + FileOptions'CODE_SIZE | + FileOptions'LITE_RUNTIME + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +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 k + | (Prelude.==) k "SPEED" = Prelude.Just FileOptions'SPEED + | (Prelude.==) k "CODE_SIZE" = Prelude.Just FileOptions'CODE_SIZE + | (Prelude.==) k "LITE_RUNTIME" + = Prelude.Just FileOptions'LITE_RUNTIME + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded FileOptions'OptimizeMode where + minBound = FileOptions'SPEED + maxBound = FileOptions'LITE_RUNTIME +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 Data.ProtoLens.FieldDefault FileOptions'OptimizeMode where + fieldDefault = FileOptions'SPEED +instance Control.DeepSeq.NFData FileOptions'OptimizeMode where + rnf x__ = Prelude.seq x__ () +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.annotation' @:: Lens' GeneratedCodeInfo [GeneratedCodeInfo'Annotation]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'annotation' @:: Lens' GeneratedCodeInfo (Data.Vector.Vector GeneratedCodeInfo'Annotation)@ -} +data GeneratedCodeInfo + = GeneratedCodeInfo'_constructor {_GeneratedCodeInfo'annotation :: !(Data.Vector.Vector GeneratedCodeInfo'Annotation), + _GeneratedCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show GeneratedCodeInfo where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo "annotation" [GeneratedCodeInfo'Annotation] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'annotation + (\ x__ y__ -> x__ {_GeneratedCodeInfo'annotation = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo "vec'annotation" (Data.Vector.Vector GeneratedCodeInfo'Annotation) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'annotation + (\ x__ y__ -> x__ {_GeneratedCodeInfo'annotation = y__})) + Prelude.id +instance Data.ProtoLens.Message GeneratedCodeInfo where + messageName _ = Data.Text.pack "google.protobuf.GeneratedCodeInfo" + packedMessageDescriptor _ + = "\n\ + \\DC1GeneratedCodeInfo\DC2M\n\ + \\n\ + \annotation\CAN\SOH \ETX(\v2-.google.protobuf.GeneratedCodeInfo.AnnotationR\n\ + \annotation\SUB\235\SOH\n\ + \\n\ + \Annotation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\US\n\ + \\vsource_file\CAN\STX \SOH(\tR\n\ + \sourceFile\DC2\DC4\n\ + \\ENQbegin\CAN\ETX \SOH(\ENQR\ENQbegin\DC2\DLE\n\ + \\ETXend\CAN\EOT \SOH(\ENQR\ETXend\DC2R\n\ + \\bsemantic\CAN\ENQ \SOH(\SO26.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\bsemantic\"(\n\ + \\bSemantic\DC2\b\n\ + \\EOTNONE\DLE\NUL\DC2\a\n\ + \\ETXSET\DLE\SOH\DC2\t\n\ + \\ENQALIAS\DLE\STX" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = GeneratedCodeInfo'_constructor + {_GeneratedCodeInfo'annotation = Data.Vector.Generic.empty, + _GeneratedCodeInfo'_unknownFields = []} + parseMessage + = let + loop :: + GeneratedCodeInfo + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld GeneratedCodeInfo'Annotation + -> Data.ProtoLens.Encoding.Bytes.Parser GeneratedCodeInfo + loop x mutable'annotation + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'annotation <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'annotation) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'annotation") + frozen'annotation + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "annotation" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'annotation y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'annotation + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'annotation <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'annotation) + "GeneratedCodeInfo" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'annotation") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)) +instance Control.DeepSeq.NFData GeneratedCodeInfo where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_GeneratedCodeInfo'_unknownFields x__) + (Control.DeepSeq.deepseq (_GeneratedCodeInfo'annotation x__) ()) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' GeneratedCodeInfo'Annotation [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'path' @:: Lens' GeneratedCodeInfo'Annotation (Data.Vector.Unboxed.Vector 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)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.semantic' @:: Lens' GeneratedCodeInfo'Annotation GeneratedCodeInfo'Annotation'Semantic@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'semantic' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe GeneratedCodeInfo'Annotation'Semantic)@ -} +data GeneratedCodeInfo'Annotation + = GeneratedCodeInfo'Annotation'_constructor {_GeneratedCodeInfo'Annotation'path :: !(Data.Vector.Unboxed.Vector 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'semantic :: !(Prelude.Maybe GeneratedCodeInfo'Annotation'Semantic), + _GeneratedCodeInfo'Annotation'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show GeneratedCodeInfo'Annotation where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "path" [Data.Int.Int32] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'path + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'path = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "vec'path" (Data.Vector.Unboxed.Vector Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'path + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'path = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "sourceFile" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'sourceFile + (\ x__ y__ + -> x__ {_GeneratedCodeInfo'Annotation'sourceFile = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'sourceFile" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'sourceFile + (\ x__ y__ + -> x__ {_GeneratedCodeInfo'Annotation'sourceFile = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "begin" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'begin + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'begin = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'begin" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'begin + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'begin = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "end" Data.Int.Int32 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'end + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'end = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'end" (Prelude.Maybe Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'end + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'end = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "semantic" GeneratedCodeInfo'Annotation'Semantic where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'semantic + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'semantic = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'semantic" (Prelude.Maybe GeneratedCodeInfo'Annotation'Semantic) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'semantic + (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'semantic = y__})) + Prelude.id +instance Data.ProtoLens.Message GeneratedCodeInfo'Annotation where + messageName _ + = Data.Text.pack "google.protobuf.GeneratedCodeInfo.Annotation" + packedMessageDescriptor _ + = "\n\ + \\n\ + \Annotation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\US\n\ + \\vsource_file\CAN\STX \SOH(\tR\n\ + \sourceFile\DC2\DC4\n\ + \\ENQbegin\CAN\ETX \SOH(\ENQR\ENQbegin\DC2\DLE\n\ + \\ETXend\CAN\EOT \SOH(\ENQR\ETXend\DC2R\n\ + \\bsemantic\CAN\ENQ \SOH(\SO26.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\bsemantic\"(\n\ + \\bSemantic\DC2\b\n\ + \\EOTNONE\DLE\NUL\DC2\a\n\ + \\ETXSET\DLE\SOH\DC2\t\n\ + \\ENQALIAS\DLE\STX" + packedFileDescriptor _ = packedFileDescriptor + 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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'end")) :: + Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation + semantic__field_descriptor + = Data.ProtoLens.FieldDescriptor + "semantic" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor GeneratedCodeInfo'Annotation'Semantic) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'semantic")) :: + 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), + (Data.ProtoLens.Tag 5, semantic__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'_unknownFields + (\ x__ y__ + -> x__ {_GeneratedCodeInfo'Annotation'_unknownFields = y__}) + defMessage + = GeneratedCodeInfo'Annotation'_constructor + {_GeneratedCodeInfo'Annotation'path = Data.Vector.Generic.empty, + _GeneratedCodeInfo'Annotation'sourceFile = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'begin = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'end = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'semantic = Prelude.Nothing, + _GeneratedCodeInfo'Annotation'_unknownFields = []} + parseMessage + = let + loop :: + GeneratedCodeInfo'Annotation + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32 + -> Data.ProtoLens.Encoding.Bytes.Parser GeneratedCodeInfo'Annotation + loop x mutable'path + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'path) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'path") frozen'path x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "path" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'path y) + loop x v + 10 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "path" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'path) + loop x y + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "source_file" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"sourceFile") y x) + mutable'path + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "begin" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"begin") y x) + mutable'path + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "end" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x) + mutable'path + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "semantic" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"semantic") y x) + mutable'path + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'path + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'path) + "Annotation" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (let + p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'path") _x + in + if Data.Vector.Generic.null p then + Data.Monoid.mempty + else + (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + (Data.ProtoLens.Encoding.Bytes.runBuilder + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + p)))) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'sourceFile") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'begin") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'semantic") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + Prelude.fromIntegral) + Prelude.fromEnum + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData GeneratedCodeInfo'Annotation where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'_unknownFields x__) + (Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'path x__) + (Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'sourceFile x__) + (Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'begin x__) + (Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'end x__) + (Control.DeepSeq.deepseq + (_GeneratedCodeInfo'Annotation'semantic x__) ()))))) +data GeneratedCodeInfo'Annotation'Semantic + = GeneratedCodeInfo'Annotation'NONE | + GeneratedCodeInfo'Annotation'SET | + GeneratedCodeInfo'Annotation'ALIAS + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum GeneratedCodeInfo'Annotation'Semantic where + maybeToEnum 0 = Prelude.Just GeneratedCodeInfo'Annotation'NONE + maybeToEnum 1 = Prelude.Just GeneratedCodeInfo'Annotation'SET + maybeToEnum 2 = Prelude.Just GeneratedCodeInfo'Annotation'ALIAS + maybeToEnum _ = Prelude.Nothing + showEnum GeneratedCodeInfo'Annotation'NONE = "NONE" + showEnum GeneratedCodeInfo'Annotation'SET = "SET" + showEnum GeneratedCodeInfo'Annotation'ALIAS = "ALIAS" + readEnum k + | (Prelude.==) k "NONE" + = Prelude.Just GeneratedCodeInfo'Annotation'NONE + | (Prelude.==) k "SET" + = Prelude.Just GeneratedCodeInfo'Annotation'SET + | (Prelude.==) k "ALIAS" + = Prelude.Just GeneratedCodeInfo'Annotation'ALIAS + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded GeneratedCodeInfo'Annotation'Semantic where + minBound = GeneratedCodeInfo'Annotation'NONE + maxBound = GeneratedCodeInfo'Annotation'ALIAS +instance Prelude.Enum GeneratedCodeInfo'Annotation'Semantic where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum Semantic: " (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum GeneratedCodeInfo'Annotation'NONE = 0 + fromEnum GeneratedCodeInfo'Annotation'SET = 1 + fromEnum GeneratedCodeInfo'Annotation'ALIAS = 2 + succ GeneratedCodeInfo'Annotation'ALIAS + = Prelude.error + "GeneratedCodeInfo'Annotation'Semantic.succ: bad argument GeneratedCodeInfo'Annotation'ALIAS. This value would be out of bounds." + succ GeneratedCodeInfo'Annotation'NONE + = GeneratedCodeInfo'Annotation'SET + succ GeneratedCodeInfo'Annotation'SET + = GeneratedCodeInfo'Annotation'ALIAS + pred GeneratedCodeInfo'Annotation'NONE + = Prelude.error + "GeneratedCodeInfo'Annotation'Semantic.pred: bad argument GeneratedCodeInfo'Annotation'NONE. This value would be out of bounds." + pred GeneratedCodeInfo'Annotation'SET + = GeneratedCodeInfo'Annotation'NONE + pred GeneratedCodeInfo'Annotation'ALIAS + = GeneratedCodeInfo'Annotation'SET + 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 Data.ProtoLens.FieldDefault GeneratedCodeInfo'Annotation'Semantic where + fieldDefault = GeneratedCodeInfo'Annotation'NONE +instance Control.DeepSeq.NFData GeneratedCodeInfo'Annotation'Semantic where + rnf x__ = Prelude.seq x__ () +{- | 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.deprecatedLegacyJsonFieldConflicts' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecatedLegacyJsonFieldConflicts' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' MessageOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' MessageOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MessageOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' MessageOptions (Data.Vector.Vector UninterpretedOption)@ -} +data MessageOptions + = MessageOptions'_constructor {_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'deprecatedLegacyJsonFieldConflicts :: !(Prelude.Maybe Prelude.Bool), + _MessageOptions'features :: !(Prelude.Maybe FeatureSet), + _MessageOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _MessageOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show MessageOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField MessageOptions "messageSetWireFormat" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'messageSetWireFormat + (\ x__ y__ -> x__ {_MessageOptions'messageSetWireFormat = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'messageSetWireFormat" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'messageSetWireFormat + (\ x__ y__ -> x__ {_MessageOptions'messageSetWireFormat = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "noStandardDescriptorAccessor" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'noStandardDescriptorAccessor + (\ x__ y__ + -> x__ {_MessageOptions'noStandardDescriptorAccessor = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'noStandardDescriptorAccessor" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'noStandardDescriptorAccessor + (\ x__ y__ + -> x__ {_MessageOptions'noStandardDescriptorAccessor = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'deprecated + (\ x__ y__ -> x__ {_MessageOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'deprecated + (\ x__ y__ -> x__ {_MessageOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "mapEntry" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'mapEntry + (\ x__ y__ -> x__ {_MessageOptions'mapEntry = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'mapEntry" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'mapEntry + (\ x__ y__ -> x__ {_MessageOptions'mapEntry = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "deprecatedLegacyJsonFieldConflicts" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'deprecatedLegacyJsonFieldConflicts + (\ x__ y__ + -> x__ {_MessageOptions'deprecatedLegacyJsonFieldConflicts = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'deprecatedLegacyJsonFieldConflicts" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'deprecatedLegacyJsonFieldConflicts + (\ x__ y__ + -> x__ {_MessageOptions'deprecatedLegacyJsonFieldConflicts = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'features + (\ x__ y__ -> x__ {_MessageOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField MessageOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'features + (\ x__ y__ -> x__ {_MessageOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MessageOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'uninterpretedOption + (\ x__ y__ -> x__ {_MessageOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField MessageOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MessageOptions'uninterpretedOption + (\ x__ y__ -> x__ {_MessageOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message MessageOptions where + messageName _ = Data.Text.pack "google.protobuf.MessageOptions" + packedMessageDescriptor _ + = "\n\ + \\SOMessageOptions\DC2<\n\ + \\ETBmessage_set_wire_format\CAN\SOH \SOH(\b:\ENQfalseR\DC4messageSetWireFormat\DC2L\n\ + \\USno_standard_descriptor_accessor\CAN\STX \SOH(\b:\ENQfalseR\FSnoStandardDescriptorAccessor\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2\ESC\n\ + \\tmap_entry\CAN\a \SOH(\bR\bmapEntry\DC2V\n\ + \&deprecated_legacy_json_field_conflicts\CAN\v \SOH(\bR\"deprecatedLegacyJsonFieldConflictsB\STX\CAN\SOH\DC27\n\ + \\bfeatures\CAN\f \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\EOT\DLE\ENQJ\EOT\b\ENQ\DLE\ACKJ\EOT\b\ACK\DLE\aJ\EOT\b\b\DLE\tJ\EOT\b\t\DLE\n" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field + @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"maybe'mapEntry")) :: + Data.ProtoLens.FieldDescriptor MessageOptions + deprecatedLegacyJsonFieldConflicts__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecated_legacy_json_field_conflicts" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field + @"maybe'deprecatedLegacyJsonFieldConflicts")) :: + Data.ProtoLens.FieldDescriptor MessageOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + 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 + (Data.ProtoLens.Field.field @"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 11, + deprecatedLegacyJsonFieldConflicts__field_descriptor), + (Data.ProtoLens.Tag 12, features__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _MessageOptions'_unknownFields + (\ x__ y__ -> x__ {_MessageOptions'_unknownFields = y__}) + defMessage + = MessageOptions'_constructor + {_MessageOptions'messageSetWireFormat = Prelude.Nothing, + _MessageOptions'noStandardDescriptorAccessor = Prelude.Nothing, + _MessageOptions'deprecated = Prelude.Nothing, + _MessageOptions'mapEntry = Prelude.Nothing, + _MessageOptions'deprecatedLegacyJsonFieldConflicts = Prelude.Nothing, + _MessageOptions'features = Prelude.Nothing, + _MessageOptions'uninterpretedOption = Data.Vector.Generic.empty, + _MessageOptions'_unknownFields = []} + parseMessage + = let + loop :: + MessageOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser MessageOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "message_set_wire_format" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"messageSetWireFormat") y x) + mutable'uninterpretedOption + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "no_standard_descriptor_accessor" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"noStandardDescriptorAccessor") + y + x) + mutable'uninterpretedOption + 24 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 56 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "map_entry" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"mapEntry") y x) + mutable'uninterpretedOption + 88 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated_legacy_json_field_conflicts" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field + @"deprecatedLegacyJsonFieldConflicts") + y + x) + mutable'uninterpretedOption + 98 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "MessageOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'messageSetWireFormat") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 8) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'noStandardDescriptorAccessor") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 24) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'mapEntry") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 56) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field + @"maybe'deprecatedLegacyJsonFieldConflicts") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 88) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 98) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))))) +instance Control.DeepSeq.NFData MessageOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_MessageOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_MessageOptions'messageSetWireFormat x__) + (Control.DeepSeq.deepseq + (_MessageOptions'noStandardDescriptorAccessor x__) + (Control.DeepSeq.deepseq + (_MessageOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_MessageOptions'mapEntry x__) + (Control.DeepSeq.deepseq + (_MessageOptions'deprecatedLegacyJsonFieldConflicts x__) + (Control.DeepSeq.deepseq + (_MessageOptions'features x__) + (Control.DeepSeq.deepseq + (_MessageOptions'uninterpretedOption x__) ()))))))) +{- | 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'_constructor {_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 stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show MethodDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'name + (\ x__ y__ -> x__ {_MethodDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'name + (\ x__ y__ -> x__ {_MethodDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "inputType" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'inputType + (\ x__ y__ -> x__ {_MethodDescriptorProto'inputType = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'inputType" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'inputType + (\ x__ y__ -> x__ {_MethodDescriptorProto'inputType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "outputType" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'outputType + (\ x__ y__ -> x__ {_MethodDescriptorProto'outputType = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'outputType" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'outputType + (\ x__ y__ -> x__ {_MethodDescriptorProto'outputType = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "options" MethodOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'options + (\ x__ y__ -> x__ {_MethodDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'options" (Prelude.Maybe MethodOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'options + (\ x__ y__ -> x__ {_MethodDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "clientStreaming" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'clientStreaming + (\ x__ y__ -> x__ {_MethodDescriptorProto'clientStreaming = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'clientStreaming" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'clientStreaming + (\ x__ y__ -> x__ {_MethodDescriptorProto'clientStreaming = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "serverStreaming" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'serverStreaming + (\ x__ y__ -> x__ {_MethodDescriptorProto'serverStreaming = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'serverStreaming" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodDescriptorProto'serverStreaming + (\ x__ y__ -> x__ {_MethodDescriptorProto'serverStreaming = y__})) + Prelude.id +instance Data.ProtoLens.Message MethodDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.MethodDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\NAKMethodDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\GS\n\ + \\n\ + \input_type\CAN\STX \SOH(\tR\tinputType\DC2\US\n\ + \\voutput_type\CAN\ETX \SOH(\tR\n\ + \outputType\DC28\n\ + \\aoptions\CAN\EOT \SOH(\v2\RS.google.protobuf.MethodOptionsR\aoptions\DC20\n\ + \\DLEclient_streaming\CAN\ENQ \SOH(\b:\ENQfalseR\SIclientStreaming\DC20\n\ + \\DLEserver_streaming\CAN\ACK \SOH(\b:\ENQfalseR\SIserverStreaming" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = MethodDescriptorProto'_constructor + {_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 = []} + parseMessage + = let + loop :: + MethodDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser MethodDescriptorProto + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "input_type" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"inputType") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "output_type" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"outputType") y x) + 34 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "client_streaming" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"clientStreaming") y x) + 48 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "server_streaming" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"serverStreaming") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "MethodDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'inputType") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'outputType") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'clientStreaming") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'serverStreaming") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 48) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))) +instance Control.DeepSeq.NFData MethodDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_MethodDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'inputType x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'outputType x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'options x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'clientStreaming x__) + (Control.DeepSeq.deepseq + (_MethodDescriptorProto'serverStreaming x__) ())))))) +{- | 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.idempotencyLevel' @:: Lens' MethodOptions MethodOptions'IdempotencyLevel@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'idempotencyLevel' @:: Lens' MethodOptions (Prelude.Maybe MethodOptions'IdempotencyLevel)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' MethodOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' MethodOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MethodOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' MethodOptions (Data.Vector.Vector UninterpretedOption)@ -} +data MethodOptions + = MethodOptions'_constructor {_MethodOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _MethodOptions'idempotencyLevel :: !(Prelude.Maybe MethodOptions'IdempotencyLevel), + _MethodOptions'features :: !(Prelude.Maybe FeatureSet), + _MethodOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _MethodOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show MethodOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField MethodOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'deprecated + (\ x__ y__ -> x__ {_MethodOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField MethodOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'deprecated + (\ x__ y__ -> x__ {_MethodOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodOptions "idempotencyLevel" MethodOptions'IdempotencyLevel where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'idempotencyLevel + (\ x__ y__ -> x__ {_MethodOptions'idempotencyLevel = y__})) + (Data.ProtoLens.maybeLens MethodOptions'IDEMPOTENCY_UNKNOWN) +instance Data.ProtoLens.Field.HasField MethodOptions "maybe'idempotencyLevel" (Prelude.Maybe MethodOptions'IdempotencyLevel) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'idempotencyLevel + (\ x__ y__ -> x__ {_MethodOptions'idempotencyLevel = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'features + (\ x__ y__ -> x__ {_MethodOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField MethodOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'features + (\ x__ y__ -> x__ {_MethodOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField MethodOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'uninterpretedOption + (\ x__ y__ -> x__ {_MethodOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField MethodOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _MethodOptions'uninterpretedOption + (\ x__ y__ -> x__ {_MethodOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message MethodOptions where + messageName _ = Data.Text.pack "google.protobuf.MethodOptions" + packedMessageDescriptor _ + = "\n\ + \\rMethodOptions\DC2%\n\ + \\n\ + \deprecated\CAN! \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2q\n\ + \\DC1idempotency_level\CAN\" \SOH(\SO2/.google.protobuf.MethodOptions.IdempotencyLevel:\DC3IDEMPOTENCY_UNKNOWNR\DLEidempotencyLevel\DC27\n\ + \\bfeatures\CAN# \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\"P\n\ + \\DLEIdempotencyLevel\DC2\ETB\n\ + \\DC3IDEMPOTENCY_UNKNOWN\DLE\NUL\DC2\DC3\n\ + \\SINO_SIDE_EFFECTS\DLE\SOH\DC2\SO\n\ + \\n\ + \IDEMPOTENT\DLE\STX*\t\b\232\a\DLE\128\128\128\128\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'deprecated")) :: + Data.ProtoLens.FieldDescriptor MethodOptions + idempotencyLevel__field_descriptor + = Data.ProtoLens.FieldDescriptor + "idempotency_level" + (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField :: + Data.ProtoLens.FieldTypeDescriptor MethodOptions'IdempotencyLevel) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'idempotencyLevel")) :: + Data.ProtoLens.FieldDescriptor MethodOptions + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + 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 + (Data.ProtoLens.Field.field @"uninterpretedOption")) :: + Data.ProtoLens.FieldDescriptor MethodOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 33, deprecated__field_descriptor), + (Data.ProtoLens.Tag 34, idempotencyLevel__field_descriptor), + (Data.ProtoLens.Tag 35, features__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _MethodOptions'_unknownFields + (\ x__ y__ -> x__ {_MethodOptions'_unknownFields = y__}) + defMessage + = MethodOptions'_constructor + {_MethodOptions'deprecated = Prelude.Nothing, + _MethodOptions'idempotencyLevel = Prelude.Nothing, + _MethodOptions'features = Prelude.Nothing, + _MethodOptions'uninterpretedOption = Data.Vector.Generic.empty, + _MethodOptions'_unknownFields = []} + parseMessage + = let + loop :: + MethodOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser MethodOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 264 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 272 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "idempotency_level" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"idempotencyLevel") y x) + mutable'uninterpretedOption + 282 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "MethodOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 264) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'idempotencyLevel") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 272) + ((Prelude..) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + Prelude.fromEnum + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 282) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))))) +instance Control.DeepSeq.NFData MethodOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_MethodOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_MethodOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_MethodOptions'idempotencyLevel x__) + (Control.DeepSeq.deepseq + (_MethodOptions'features x__) + (Control.DeepSeq.deepseq + (_MethodOptions'uninterpretedOption x__) ())))) +data MethodOptions'IdempotencyLevel + = MethodOptions'IDEMPOTENCY_UNKNOWN | + MethodOptions'NO_SIDE_EFFECTS | + MethodOptions'IDEMPOTENT + deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord) +instance Data.ProtoLens.MessageEnum MethodOptions'IdempotencyLevel where + maybeToEnum 0 = Prelude.Just MethodOptions'IDEMPOTENCY_UNKNOWN + maybeToEnum 1 = Prelude.Just MethodOptions'NO_SIDE_EFFECTS + maybeToEnum 2 = Prelude.Just MethodOptions'IDEMPOTENT + maybeToEnum _ = Prelude.Nothing + showEnum MethodOptions'IDEMPOTENCY_UNKNOWN = "IDEMPOTENCY_UNKNOWN" + showEnum MethodOptions'NO_SIDE_EFFECTS = "NO_SIDE_EFFECTS" + showEnum MethodOptions'IDEMPOTENT = "IDEMPOTENT" + readEnum k + | (Prelude.==) k "IDEMPOTENCY_UNKNOWN" + = Prelude.Just MethodOptions'IDEMPOTENCY_UNKNOWN + | (Prelude.==) k "NO_SIDE_EFFECTS" + = Prelude.Just MethodOptions'NO_SIDE_EFFECTS + | (Prelude.==) k "IDEMPOTENT" + = Prelude.Just MethodOptions'IDEMPOTENT + | Prelude.otherwise + = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum +instance Prelude.Bounded MethodOptions'IdempotencyLevel where + minBound = MethodOptions'IDEMPOTENCY_UNKNOWN + maxBound = MethodOptions'IDEMPOTENT +instance Prelude.Enum MethodOptions'IdempotencyLevel where + toEnum k__ + = Prelude.maybe + (Prelude.error + ((Prelude.++) + "toEnum: unknown value for enum IdempotencyLevel: " + (Prelude.show k__))) + Prelude.id + (Data.ProtoLens.maybeToEnum k__) + fromEnum MethodOptions'IDEMPOTENCY_UNKNOWN = 0 + fromEnum MethodOptions'NO_SIDE_EFFECTS = 1 + fromEnum MethodOptions'IDEMPOTENT = 2 + succ MethodOptions'IDEMPOTENT + = Prelude.error + "MethodOptions'IdempotencyLevel.succ: bad argument MethodOptions'IDEMPOTENT. This value would be out of bounds." + succ MethodOptions'IDEMPOTENCY_UNKNOWN + = MethodOptions'NO_SIDE_EFFECTS + succ MethodOptions'NO_SIDE_EFFECTS = MethodOptions'IDEMPOTENT + pred MethodOptions'IDEMPOTENCY_UNKNOWN + = Prelude.error + "MethodOptions'IdempotencyLevel.pred: bad argument MethodOptions'IDEMPOTENCY_UNKNOWN. This value would be out of bounds." + pred MethodOptions'NO_SIDE_EFFECTS + = MethodOptions'IDEMPOTENCY_UNKNOWN + pred MethodOptions'IDEMPOTENT = MethodOptions'NO_SIDE_EFFECTS + 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 Data.ProtoLens.FieldDefault MethodOptions'IdempotencyLevel where + fieldDefault = MethodOptions'IDEMPOTENCY_UNKNOWN +instance Control.DeepSeq.NFData MethodOptions'IdempotencyLevel where + rnf x__ = Prelude.seq x__ () +{- | 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)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' OneofDescriptorProto OneofOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' OneofDescriptorProto (Prelude.Maybe OneofOptions)@ -} +data OneofDescriptorProto + = OneofDescriptorProto'_constructor {_OneofDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text), + _OneofDescriptorProto'options :: !(Prelude.Maybe OneofOptions), + _OneofDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show OneofDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField OneofDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofDescriptorProto'name + (\ x__ y__ -> x__ {_OneofDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField OneofDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofDescriptorProto'name + (\ x__ y__ -> x__ {_OneofDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField OneofDescriptorProto "options" OneofOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofDescriptorProto'options + (\ x__ y__ -> x__ {_OneofDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField OneofDescriptorProto "maybe'options" (Prelude.Maybe OneofOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofDescriptorProto'options + (\ x__ y__ -> x__ {_OneofDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Message OneofDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.OneofDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\DC4OneofDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC27\n\ + \\aoptions\CAN\STX \SOH(\v2\GS.google.protobuf.OneofOptionsR\aoptions" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'name")) :: + Data.ProtoLens.FieldDescriptor OneofDescriptorProto + options__field_descriptor + = Data.ProtoLens.FieldDescriptor + "options" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor OneofOptions) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'options")) :: + Data.ProtoLens.FieldDescriptor OneofDescriptorProto + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _OneofDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_OneofDescriptorProto'_unknownFields = y__}) + defMessage + = OneofDescriptorProto'_constructor + {_OneofDescriptorProto'name = Prelude.Nothing, + _OneofDescriptorProto'options = Prelude.Nothing, + _OneofDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + OneofDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser OneofDescriptorProto + loop x + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage) "OneofDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData OneofDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_OneofDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_OneofDescriptorProto'name x__) + (Control.DeepSeq.deepseq (_OneofDescriptorProto'options x__) ())) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' OneofOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' OneofOptions (Prelude.Maybe FeatureSet)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' OneofOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' OneofOptions (Data.Vector.Vector UninterpretedOption)@ -} +data OneofOptions + = OneofOptions'_constructor {_OneofOptions'features :: !(Prelude.Maybe FeatureSet), + _OneofOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _OneofOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show OneofOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField OneofOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofOptions'features + (\ x__ y__ -> x__ {_OneofOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField OneofOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofOptions'features + (\ x__ y__ -> x__ {_OneofOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField OneofOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofOptions'uninterpretedOption + (\ x__ y__ -> x__ {_OneofOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField OneofOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _OneofOptions'uninterpretedOption + (\ x__ y__ -> x__ {_OneofOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message OneofOptions where + messageName _ = Data.Text.pack "google.protobuf.OneofOptions" + packedMessageDescriptor _ + = "\n\ + \\fOneofOptions\DC27\n\ + \\bfeatures\CAN\SOH \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + Data.ProtoLens.FieldDescriptor OneofOptions + uninterpretedOption__field_descriptor + = Data.ProtoLens.FieldDescriptor + "uninterpreted_option" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor UninterpretedOption) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Unpacked + (Data.ProtoLens.Field.field @"uninterpretedOption")) :: + Data.ProtoLens.FieldDescriptor OneofOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, features__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _OneofOptions'_unknownFields + (\ x__ y__ -> x__ {_OneofOptions'_unknownFields = y__}) + defMessage + = OneofOptions'_constructor + {_OneofOptions'features = Prelude.Nothing, + _OneofOptions'uninterpretedOption = Data.Vector.Generic.empty, + _OneofOptions'_unknownFields = []} + parseMessage + = let + loop :: + OneofOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser OneofOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "OneofOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData OneofOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_OneofOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_OneofOptions'features x__) + (Control.DeepSeq.deepseq + (_OneofOptions'uninterpretedOption x__) ())) +{- | 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.vec'method' @:: Lens' ServiceDescriptorProto (Data.Vector.Vector 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'_constructor {_ServiceDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text), + _ServiceDescriptorProto'method :: !(Data.Vector.Vector MethodDescriptorProto), + _ServiceDescriptorProto'options :: !(Prelude.Maybe ServiceOptions), + _ServiceDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show ServiceDescriptorProto where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "name" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'name + (\ x__ y__ -> x__ {_ServiceDescriptorProto'name = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'name + (\ x__ y__ -> x__ {_ServiceDescriptorProto'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "method" [MethodDescriptorProto] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'method + (\ x__ y__ -> x__ {_ServiceDescriptorProto'method = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "vec'method" (Data.Vector.Vector MethodDescriptorProto) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'method + (\ x__ y__ -> x__ {_ServiceDescriptorProto'method = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "options" ServiceOptions where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'options + (\ x__ y__ -> x__ {_ServiceDescriptorProto'options = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "maybe'options" (Prelude.Maybe ServiceOptions) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceDescriptorProto'options + (\ x__ y__ -> x__ {_ServiceDescriptorProto'options = y__})) + Prelude.id +instance Data.ProtoLens.Message ServiceDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.ServiceDescriptorProto" + packedMessageDescriptor _ + = "\n\ + \\SYNServiceDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2>\n\ + \\ACKmethod\CAN\STX \ETX(\v2&.google.protobuf.MethodDescriptorProtoR\ACKmethod\DC29\n\ + \\aoptions\CAN\ETX \SOH(\v2\US.google.protobuf.ServiceOptionsR\aoptions" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = ServiceDescriptorProto'_constructor + {_ServiceDescriptorProto'name = Prelude.Nothing, + _ServiceDescriptorProto'method = Data.Vector.Generic.empty, + _ServiceDescriptorProto'options = Prelude.Nothing, + _ServiceDescriptorProto'_unknownFields = []} + parseMessage + = let + loop :: + ServiceDescriptorProto + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld MethodDescriptorProto + -> Data.ProtoLens.Encoding.Bytes.Parser ServiceDescriptorProto + loop x mutable'method + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'method <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'method) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'method") frozen'method x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + mutable'method + 18 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "method" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'method y) + loop x v + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "options" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x) + mutable'method + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'method + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'method <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'method) + "ServiceDescriptorProto" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'method") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData ServiceDescriptorProto where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_ServiceDescriptorProto'_unknownFields x__) + (Control.DeepSeq.deepseq + (_ServiceDescriptorProto'name x__) + (Control.DeepSeq.deepseq + (_ServiceDescriptorProto'method x__) + (Control.DeepSeq.deepseq + (_ServiceDescriptorProto'options x__) ()))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.features' @:: Lens' ServiceOptions FeatureSet@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'features' @:: Lens' ServiceOptions (Prelude.Maybe FeatureSet)@ + * '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]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' ServiceOptions (Data.Vector.Vector UninterpretedOption)@ -} +data ServiceOptions + = ServiceOptions'_constructor {_ServiceOptions'features :: !(Prelude.Maybe FeatureSet), + _ServiceOptions'deprecated :: !(Prelude.Maybe Prelude.Bool), + _ServiceOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _ServiceOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show ServiceOptions where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField ServiceOptions "features" FeatureSet where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'features + (\ x__ y__ -> x__ {_ServiceOptions'features = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage) +instance Data.ProtoLens.Field.HasField ServiceOptions "maybe'features" (Prelude.Maybe FeatureSet) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'features + (\ x__ y__ -> x__ {_ServiceOptions'features = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ServiceOptions "deprecated" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'deprecated + (\ x__ y__ -> x__ {_ServiceOptions'deprecated = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField ServiceOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'deprecated + (\ x__ y__ -> x__ {_ServiceOptions'deprecated = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField ServiceOptions "uninterpretedOption" [UninterpretedOption] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'uninterpretedOption + (\ x__ y__ -> x__ {_ServiceOptions'uninterpretedOption = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField ServiceOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _ServiceOptions'uninterpretedOption + (\ x__ y__ -> x__ {_ServiceOptions'uninterpretedOption = y__})) + Prelude.id +instance Data.ProtoLens.Message ServiceOptions where + messageName _ = Data.Text.pack "google.protobuf.ServiceOptions" + packedMessageDescriptor _ + = "\n\ + \\SOServiceOptions\DC27\n\ + \\bfeatures\CAN\" \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2%\n\ + \\n\ + \deprecated\CAN! \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX" + packedFileDescriptor _ = packedFileDescriptor + fieldsByTag + = let + features__field_descriptor + = Data.ProtoLens.FieldDescriptor + "features" + (Data.ProtoLens.MessageField Data.ProtoLens.MessageType :: + Data.ProtoLens.FieldTypeDescriptor FeatureSet) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'features")) :: + Data.ProtoLens.FieldDescriptor ServiceOptions + deprecated__field_descriptor + = Data.ProtoLens.FieldDescriptor + "deprecated" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"uninterpretedOption")) :: + Data.ProtoLens.FieldDescriptor ServiceOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 34, features__field_descriptor), + (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__}) + defMessage + = ServiceOptions'_constructor + {_ServiceOptions'features = Prelude.Nothing, + _ServiceOptions'deprecated = Prelude.Nothing, + _ServiceOptions'uninterpretedOption = Data.Vector.Generic.empty, + _ServiceOptions'_unknownFields = []} + parseMessage + = let + loop :: + ServiceOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser ServiceOptions + loop x mutable'uninterpretedOption + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'uninterpretedOption) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") + frozen'uninterpretedOption + x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 274 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) Data.ProtoLens.parseMessage) + "features" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"features") y x) + mutable'uninterpretedOption + 264 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "deprecated" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x) + mutable'uninterpretedOption + 7994 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "uninterpreted_option" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'uninterpretedOption y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'uninterpretedOption + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'uninterpretedOption) + "ServiceOptions" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (case + Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'features") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 274) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'deprecated") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 264) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))) +instance Control.DeepSeq.NFData ServiceOptions where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_ServiceOptions'_unknownFields x__) + (Control.DeepSeq.deepseq + (_ServiceOptions'features x__) + (Control.DeepSeq.deepseq + (_ServiceOptions'deprecated x__) + (Control.DeepSeq.deepseq + (_ServiceOptions'uninterpretedOption x__) ()))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.location' @:: Lens' SourceCodeInfo [SourceCodeInfo'Location]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'location' @:: Lens' SourceCodeInfo (Data.Vector.Vector SourceCodeInfo'Location)@ -} +data SourceCodeInfo + = SourceCodeInfo'_constructor {_SourceCodeInfo'location :: !(Data.Vector.Vector SourceCodeInfo'Location), + _SourceCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show SourceCodeInfo where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo "location" [SourceCodeInfo'Location] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'location + (\ x__ y__ -> x__ {_SourceCodeInfo'location = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo "vec'location" (Data.Vector.Vector SourceCodeInfo'Location) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'location + (\ x__ y__ -> x__ {_SourceCodeInfo'location = y__})) + Prelude.id +instance Data.ProtoLens.Message SourceCodeInfo where + messageName _ = Data.Text.pack "google.protobuf.SourceCodeInfo" + packedMessageDescriptor _ + = "\n\ + \\SOSourceCodeInfo\DC2D\n\ + \\blocation\CAN\SOH \ETX(\v2(.google.protobuf.SourceCodeInfo.LocationR\blocation\SUB\206\SOH\n\ + \\bLocation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\SYN\n\ + \\EOTspan\CAN\STX \ETX(\ENQR\EOTspanB\STX\DLE\SOH\DC2)\n\ + \\DLEleading_comments\CAN\ETX \SOH(\tR\SIleadingComments\DC2+\n\ + \\DC1trailing_comments\CAN\EOT \SOH(\tR\DLEtrailingComments\DC2:\n\ + \\EMleading_detached_comments\CAN\ACK \ETX(\tR\ETBleadingDetachedComments" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = SourceCodeInfo'_constructor + {_SourceCodeInfo'location = Data.Vector.Generic.empty, + _SourceCodeInfo'_unknownFields = []} + parseMessage + = let + loop :: + SourceCodeInfo + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld SourceCodeInfo'Location + -> Data.ProtoLens.Encoding.Bytes.Parser SourceCodeInfo + loop x mutable'location + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'location <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'location) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'location") frozen'location x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "location" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'location y) + loop x v + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'location + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'location <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'location) + "SourceCodeInfo" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'location") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)) +instance Control.DeepSeq.NFData SourceCodeInfo where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_SourceCodeInfo'_unknownFields x__) + (Control.DeepSeq.deepseq (_SourceCodeInfo'location x__) ()) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'path' @:: Lens' SourceCodeInfo'Location (Data.Vector.Unboxed.Vector Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.span' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'span' @:: Lens' SourceCodeInfo'Location (Data.Vector.Unboxed.Vector 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]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'leadingDetachedComments' @:: Lens' SourceCodeInfo'Location (Data.Vector.Vector Data.Text.Text)@ -} +data SourceCodeInfo'Location + = SourceCodeInfo'Location'_constructor {_SourceCodeInfo'Location'path :: !(Data.Vector.Unboxed.Vector Data.Int.Int32), + _SourceCodeInfo'Location'span :: !(Data.Vector.Unboxed.Vector Data.Int.Int32), + _SourceCodeInfo'Location'leadingComments :: !(Prelude.Maybe Data.Text.Text), + _SourceCodeInfo'Location'trailingComments :: !(Prelude.Maybe Data.Text.Text), + _SourceCodeInfo'Location'leadingDetachedComments :: !(Data.Vector.Vector Data.Text.Text), + _SourceCodeInfo'Location'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show SourceCodeInfo'Location where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "path" [Data.Int.Int32] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'path + (\ x__ y__ -> x__ {_SourceCodeInfo'Location'path = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'path" (Data.Vector.Unboxed.Vector Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'path + (\ x__ y__ -> x__ {_SourceCodeInfo'Location'path = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "span" [Data.Int.Int32] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'span + (\ x__ y__ -> x__ {_SourceCodeInfo'Location'span = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'span" (Data.Vector.Unboxed.Vector Data.Int.Int32) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'span + (\ x__ y__ -> x__ {_SourceCodeInfo'Location'span = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "leadingComments" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'leadingComments = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "maybe'leadingComments" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'leadingComments = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "trailingComments" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'trailingComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'trailingComments = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "maybe'trailingComments" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'trailingComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'trailingComments = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "leadingDetachedComments" [Data.Text.Text] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingDetachedComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'leadingDetachedComments = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'leadingDetachedComments" (Data.Vector.Vector Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _SourceCodeInfo'Location'leadingDetachedComments + (\ x__ y__ + -> x__ {_SourceCodeInfo'Location'leadingDetachedComments = y__})) + Prelude.id +instance Data.ProtoLens.Message SourceCodeInfo'Location where + messageName _ + = Data.Text.pack "google.protobuf.SourceCodeInfo.Location" + packedMessageDescriptor _ + = "\n\ + \\bLocation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\SYN\n\ + \\EOTspan\CAN\STX \ETX(\ENQR\EOTspanB\STX\DLE\SOH\DC2)\n\ + \\DLEleading_comments\CAN\ETX \SOH(\tR\SIleadingComments\DC2+\n\ + \\DC1trailing_comments\CAN\EOT \SOH(\tR\DLEtrailingComments\DC2:\n\ + \\EMleading_detached_comments\CAN\ACK \ETX(\tR\ETBleadingDetachedComments" + packedFileDescriptor _ = packedFileDescriptor + 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 (Data.ProtoLens.Field.field @"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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = SourceCodeInfo'Location'_constructor + {_SourceCodeInfo'Location'path = Data.Vector.Generic.empty, + _SourceCodeInfo'Location'span = Data.Vector.Generic.empty, + _SourceCodeInfo'Location'leadingComments = Prelude.Nothing, + _SourceCodeInfo'Location'trailingComments = Prelude.Nothing, + _SourceCodeInfo'Location'leadingDetachedComments = Data.Vector.Generic.empty, + _SourceCodeInfo'Location'_unknownFields = []} + parseMessage + = let + loop :: + SourceCodeInfo'Location + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32 + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32 + -> Data.ProtoLens.Encoding.Bytes.Parser SourceCodeInfo'Location + loop x mutable'leadingDetachedComments mutable'path mutable'span + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'leadingDetachedComments <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze + mutable'leadingDetachedComments) + frozen'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'path) + frozen'span <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'span) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'leadingDetachedComments") + frozen'leadingDetachedComments + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'path") + frozen'path + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'span") frozen'span x)))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 8 -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "path" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'path y) + loop x mutable'leadingDetachedComments v mutable'span + 10 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "path" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'path) + loop x mutable'leadingDetachedComments y mutable'span + 16 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "span" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'span y) + loop x mutable'leadingDetachedComments mutable'path v + 18 + -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + ((let + ploop qs + = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd + if packedEnd then + Prelude.return qs + else + do !q <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "span" + qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + qs q) + ploop qs' + in ploop) + mutable'span) + loop x mutable'leadingDetachedComments mutable'path y + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "leading_comments" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"leadingComments") y x) + mutable'leadingDetachedComments + mutable'path + mutable'span + 34 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "trailing_comments" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"trailingComments") y x) + mutable'leadingDetachedComments + mutable'path + mutable'span + 50 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "leading_detached_comments" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'leadingDetachedComments y) + loop x v mutable'path mutable'span + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'leadingDetachedComments + mutable'path + mutable'span + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'leadingDetachedComments <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + mutable'span <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop + Data.ProtoLens.defMessage + mutable'leadingDetachedComments + mutable'path + mutable'span) + "Location" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (let + p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'path") _x + in + if Data.Vector.Generic.null p then + Data.Monoid.mempty + else + (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + (Data.ProtoLens.Encoding.Bytes.runBuilder + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + p)))) + ((Data.Monoid.<>) + (let + p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'span") _x + in + if Data.Vector.Generic.null p then + Data.Monoid.mempty + else + (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + (Data.ProtoLens.Encoding.Bytes.runBuilder + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral) + p)))) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'leadingComments") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'trailingComments") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 34) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 50) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"vec'leadingDetachedComments") _x)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))) +instance Control.DeepSeq.NFData SourceCodeInfo'Location where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'_unknownFields x__) + (Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'path x__) + (Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'span x__) + (Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'leadingComments x__) + (Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'trailingComments x__) + (Control.DeepSeq.deepseq + (_SourceCodeInfo'Location'leadingDetachedComments x__) ()))))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' UninterpretedOption [UninterpretedOption'NamePart]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'name' @:: Lens' UninterpretedOption (Data.Vector.Vector 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'_constructor {_UninterpretedOption'name :: !(Data.Vector.Vector 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 stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show UninterpretedOption where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField UninterpretedOption "name" [UninterpretedOption'NamePart] where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'name + (\ x__ y__ -> x__ {_UninterpretedOption'name = y__})) + (Lens.Family2.Unchecked.lens + Data.Vector.Generic.toList + (\ _ y__ -> Data.Vector.Generic.fromList y__)) +instance Data.ProtoLens.Field.HasField UninterpretedOption "vec'name" (Data.Vector.Vector UninterpretedOption'NamePart) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'name + (\ x__ y__ -> x__ {_UninterpretedOption'name = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "identifierValue" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'identifierValue + (\ x__ y__ -> x__ {_UninterpretedOption'identifierValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'identifierValue" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'identifierValue + (\ x__ y__ -> x__ {_UninterpretedOption'identifierValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "positiveIntValue" Data.Word.Word64 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'positiveIntValue + (\ x__ y__ -> x__ {_UninterpretedOption'positiveIntValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'positiveIntValue" (Prelude.Maybe Data.Word.Word64) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'positiveIntValue + (\ x__ y__ -> x__ {_UninterpretedOption'positiveIntValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "negativeIntValue" Data.Int.Int64 where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'negativeIntValue + (\ x__ y__ -> x__ {_UninterpretedOption'negativeIntValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'negativeIntValue" (Prelude.Maybe Data.Int.Int64) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'negativeIntValue + (\ x__ y__ -> x__ {_UninterpretedOption'negativeIntValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "doubleValue" Prelude.Double where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'doubleValue + (\ x__ y__ -> x__ {_UninterpretedOption'doubleValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'doubleValue" (Prelude.Maybe Prelude.Double) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'doubleValue + (\ x__ y__ -> x__ {_UninterpretedOption'doubleValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "stringValue" Data.ByteString.ByteString where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'stringValue + (\ x__ y__ -> x__ {_UninterpretedOption'stringValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'stringValue" (Prelude.Maybe Data.ByteString.ByteString) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'stringValue + (\ x__ y__ -> x__ {_UninterpretedOption'stringValue = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption "aggregateValue" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'aggregateValue + (\ x__ y__ -> x__ {_UninterpretedOption'aggregateValue = y__})) + (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault) +instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'aggregateValue" (Prelude.Maybe Data.Text.Text) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'aggregateValue + (\ x__ y__ -> x__ {_UninterpretedOption'aggregateValue = y__})) + Prelude.id +instance Data.ProtoLens.Message UninterpretedOption where + messageName _ + = Data.Text.pack "google.protobuf.UninterpretedOption" + packedMessageDescriptor _ + = "\n\ + \\DC3UninterpretedOption\DC2A\n\ + \\EOTname\CAN\STX \ETX(\v2-.google.protobuf.UninterpretedOption.NamePartR\EOTname\DC2)\n\ + \\DLEidentifier_value\CAN\ETX \SOH(\tR\SIidentifierValue\DC2,\n\ + \\DC2positive_int_value\CAN\EOT \SOH(\EOTR\DLEpositiveIntValue\DC2,\n\ + \\DC2negative_int_value\CAN\ENQ \SOH(\ETXR\DLEnegativeIntValue\DC2!\n\ + \\fdouble_value\CAN\ACK \SOH(\SOHR\vdoubleValue\DC2!\n\ + \\fstring_value\CAN\a \SOH(\fR\vstringValue\DC2'\n\ + \\SIaggregate_value\CAN\b \SOH(\tR\SOaggregateValue\SUBJ\n\ + \\bNamePart\DC2\ESC\n\ + \\tname_part\CAN\SOH \STX(\tR\bnamePart\DC2!\n\ + \\fis_extension\CAN\STX \STX(\bR\visExtension" + packedFileDescriptor _ = packedFileDescriptor + 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 (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = UninterpretedOption'_constructor + {_UninterpretedOption'name = Data.Vector.Generic.empty, + _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 = []} + parseMessage + = let + loop :: + UninterpretedOption + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption'NamePart + -> Data.ProtoLens.Encoding.Bytes.Parser UninterpretedOption + loop x mutable'name + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do frozen'name <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'name) + (let missing = [] + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields + (\ !t -> Prelude.reverse t) + (Lens.Family2.set + (Data.ProtoLens.Field.field @"vec'name") frozen'name x)) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 18 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.isolate + (Prelude.fromIntegral len) + Data.ProtoLens.parseMessage) + "name" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append mutable'name y) + loop x v + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "identifier_value" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"identifierValue") y x) + mutable'name + 32 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + Data.ProtoLens.Encoding.Bytes.getVarInt "positive_int_value" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"positiveIntValue") y x) + mutable'name + 40 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt) + "negative_int_value" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"negativeIntValue") y x) + mutable'name + 49 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + Data.ProtoLens.Encoding.Bytes.wordToDouble + Data.ProtoLens.Encoding.Bytes.getFixed64) + "double_value" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"doubleValue") y x) + mutable'name + 58 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len)) + "string_value" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"stringValue") y x) + mutable'name + 66 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "aggregate_value" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"aggregateValue") y x) + mutable'name + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'name + in + (Data.ProtoLens.Encoding.Bytes.) + (do mutable'name <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + Data.ProtoLens.Encoding.Growing.new + loop Data.ProtoLens.defMessage mutable'name) + "UninterpretedOption" + buildMessage + = \ _x + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.foldMapBuilder + (\ _v + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 18) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.ProtoLens.encodeMessage + _v)) + (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'name") _x)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'identifierValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 26) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'positiveIntValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 32) + (Data.ProtoLens.Encoding.Bytes.putVarInt _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'negativeIntValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 40) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'doubleValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 49) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putFixed64 + Data.ProtoLens.Encoding.Bytes.doubleToWord + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'stringValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 58) + ((\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + _v)) + ((Data.Monoid.<>) + (case + Lens.Family2.view + (Data.ProtoLens.Field.field @"maybe'aggregateValue") _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 66) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral + (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + _v)) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))))) +instance Control.DeepSeq.NFData UninterpretedOption where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_UninterpretedOption'_unknownFields x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'name x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'identifierValue x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'positiveIntValue x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'negativeIntValue x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'doubleValue x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'stringValue x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'aggregateValue x__) ()))))))) +{- | 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'_constructor {_UninterpretedOption'NamePart'namePart :: !Data.Text.Text, + _UninterpretedOption'NamePart'isExtension :: !Prelude.Bool, + _UninterpretedOption'NamePart'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving stock (Prelude.Eq, Prelude.Ord) +instance Prelude.Show UninterpretedOption'NamePart where + showsPrec _ __x __s + = Prelude.showChar + '{' + (Prelude.showString + (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s)) +instance Data.ProtoLens.Field.HasField UninterpretedOption'NamePart "namePart" Data.Text.Text where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'NamePart'namePart + (\ x__ y__ -> x__ {_UninterpretedOption'NamePart'namePart = y__})) + Prelude.id +instance Data.ProtoLens.Field.HasField UninterpretedOption'NamePart "isExtension" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _UninterpretedOption'NamePart'isExtension + (\ x__ y__ + -> x__ {_UninterpretedOption'NamePart'isExtension = y__})) + Prelude.id +instance Data.ProtoLens.Message UninterpretedOption'NamePart where + messageName _ + = Data.Text.pack "google.protobuf.UninterpretedOption.NamePart" + packedMessageDescriptor _ + = "\n\ + \\bNamePart\DC2\ESC\n\ + \\tname_part\CAN\SOH \STX(\tR\bnamePart\DC2!\n\ + \\fis_extension\CAN\STX \STX(\bR\visExtension" + packedFileDescriptor _ = packedFileDescriptor + 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 + (Data.ProtoLens.Field.field @"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 + (Data.ProtoLens.Field.field @"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__}) + defMessage + = UninterpretedOption'NamePart'_constructor + {_UninterpretedOption'NamePart'namePart = Data.ProtoLens.fieldDefault, + _UninterpretedOption'NamePart'isExtension = Data.ProtoLens.fieldDefault, + _UninterpretedOption'NamePart'_unknownFields = []} + parseMessage + = let + loop :: + UninterpretedOption'NamePart + -> Prelude.Bool + -> Prelude.Bool + -> Data.ProtoLens.Encoding.Bytes.Parser UninterpretedOption'NamePart + loop x required'isExtension required'namePart + = do end <- Data.ProtoLens.Encoding.Bytes.atEnd + if end then + do (let + missing + = (if required'isExtension then (:) "is_extension" else Prelude.id) + ((if required'namePart then (:) "name_part" else Prelude.id) []) + in + if Prelude.null missing then + Prelude.return () + else + Prelude.fail + ((Prelude.++) + "Missing required fields: " + (Prelude.show (missing :: [Prelude.String])))) + Prelude.return + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getText + (Prelude.fromIntegral len)) + "name_part" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"namePart") y x) + required'isExtension + Prelude.False + 16 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "is_extension" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"isExtension") y x) + Prelude.False + required'namePart + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + required'isExtension + required'namePart + in + (Data.ProtoLens.Encoding.Bytes.) + (do loop Data.ProtoLens.defMessage Prelude.True Prelude.True) + "NamePart" + buildMessage + = \ _x + -> (Data.Monoid.<>) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 10) + ((Prelude..) + (\ bs + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt + (Prelude.fromIntegral (Data.ByteString.length bs))) + (Data.ProtoLens.Encoding.Bytes.putBytes bs)) + Data.Text.Encoding.encodeUtf8 + (Lens.Family2.view (Data.ProtoLens.Field.field @"namePart") _x))) + ((Data.Monoid.<>) + ((Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 16) + ((Prelude..) + Data.ProtoLens.Encoding.Bytes.putVarInt + (\ b -> if b then 1 else 0) + (Lens.Family2.view + (Data.ProtoLens.Field.field @"isExtension") _x))) + (Data.ProtoLens.Encoding.Wire.buildFieldSet + (Lens.Family2.view Data.ProtoLens.unknownFields _x))) +instance Control.DeepSeq.NFData UninterpretedOption'NamePart where + rnf + = \ x__ + -> Control.DeepSeq.deepseq + (_UninterpretedOption'NamePart'_unknownFields x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'NamePart'namePart x__) + (Control.DeepSeq.deepseq + (_UninterpretedOption'NamePart'isExtension x__) ())) +packedFileDescriptor :: Data.ByteString.ByteString +packedFileDescriptor + = "\n\ + \ google/protobuf/descriptor.proto\DC2\SIgoogle.protobuf\"M\n\ + \\DC1FileDescriptorSet\DC28\n\ + \\EOTfile\CAN\SOH \ETX(\v2$.google.protobuf.FileDescriptorProtoR\EOTfile\"\152\ENQ\n\ + \\DC3FileDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\CAN\n\ + \\apackage\CAN\STX \SOH(\tR\apackage\DC2\RS\n\ + \\n\ + \dependency\CAN\ETX \ETX(\tR\n\ + \dependency\DC2+\n\ + \\DC1public_dependency\CAN\n\ + \ \ETX(\ENQR\DLEpublicDependency\DC2'\n\ + \\SIweak_dependency\CAN\v \ETX(\ENQR\SOweakDependency\DC2C\n\ + \\fmessage_type\CAN\EOT \ETX(\v2 .google.protobuf.DescriptorProtoR\vmessageType\DC2A\n\ + \\tenum_type\CAN\ENQ \ETX(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\DC2A\n\ + \\aservice\CAN\ACK \ETX(\v2'.google.protobuf.ServiceDescriptorProtoR\aservice\DC2C\n\ + \\textension\CAN\a \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\textension\DC26\n\ + \\aoptions\CAN\b \SOH(\v2\FS.google.protobuf.FileOptionsR\aoptions\DC2I\n\ + \\DLEsource_code_info\CAN\t \SOH(\v2\US.google.protobuf.SourceCodeInfoR\SOsourceCodeInfo\DC2\SYN\n\ + \\ACKsyntax\CAN\f \SOH(\tR\ACKsyntax\DC22\n\ + \\aedition\CAN\SO \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\"\185\ACK\n\ + \\SIDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2;\n\ + \\ENQfield\CAN\STX \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\ENQfield\DC2C\n\ + \\textension\CAN\ACK \ETX(\v2%.google.protobuf.FieldDescriptorProtoR\textension\DC2A\n\ + \\vnested_type\CAN\ETX \ETX(\v2 .google.protobuf.DescriptorProtoR\n\ + \nestedType\DC2A\n\ + \\tenum_type\CAN\EOT \ETX(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\DC2X\n\ + \\SIextension_range\CAN\ENQ \ETX(\v2/.google.protobuf.DescriptorProto.ExtensionRangeR\SOextensionRange\DC2D\n\ + \\n\ + \oneof_decl\CAN\b \ETX(\v2%.google.protobuf.OneofDescriptorProtoR\toneofDecl\DC29\n\ + \\aoptions\CAN\a \SOH(\v2\US.google.protobuf.MessageOptionsR\aoptions\DC2U\n\ + \\SOreserved_range\CAN\t \ETX(\v2..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\DC2#\n\ + \\rreserved_name\CAN\n\ + \ \ETX(\tR\freservedName\SUBz\n\ + \\SOExtensionRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend\DC2@\n\ + \\aoptions\CAN\ETX \SOH(\v2&.google.protobuf.ExtensionRangeOptionsR\aoptions\SUB7\n\ + \\rReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend\"\204\EOT\n\ + \\NAKExtensionRangeOptions\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\DC2Y\n\ + \\vdeclaration\CAN\STX \ETX(\v22.google.protobuf.ExtensionRangeOptions.DeclarationR\vdeclarationB\ETX\136\SOH\STX\DC27\n\ + \\bfeatures\CAN2 \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2m\n\ + \\fverification\CAN\ETX \SOH(\SO28.google.protobuf.ExtensionRangeOptions.VerificationState:\n\ + \UNVERIFIEDR\fverificationB\ETX\136\SOH\STX\SUB\148\SOH\n\ + \\vDeclaration\DC2\SYN\n\ + \\ACKnumber\CAN\SOH \SOH(\ENQR\ACKnumber\DC2\ESC\n\ + \\tfull_name\CAN\STX \SOH(\tR\bfullName\DC2\DC2\n\ + \\EOTtype\CAN\ETX \SOH(\tR\EOTtype\DC2\SUB\n\ + \\breserved\CAN\ENQ \SOH(\bR\breserved\DC2\SUB\n\ + \\brepeated\CAN\ACK \SOH(\bR\brepeatedJ\EOT\b\EOT\DLE\ENQ\"4\n\ + \\DC1VerificationState\DC2\SI\n\ + \\vDECLARATION\DLE\NUL\DC2\SO\n\ + \\n\ + \UNVERIFIED\DLE\SOH*\t\b\232\a\DLE\128\128\128\128\STX\"\193\ACK\n\ + \\DC4FieldDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\SYN\n\ + \\ACKnumber\CAN\ETX \SOH(\ENQR\ACKnumber\DC2A\n\ + \\ENQlabel\CAN\EOT \SOH(\SO2+.google.protobuf.FieldDescriptorProto.LabelR\ENQlabel\DC2>\n\ + \\EOTtype\CAN\ENQ \SOH(\SO2*.google.protobuf.FieldDescriptorProto.TypeR\EOTtype\DC2\ESC\n\ + \\ttype_name\CAN\ACK \SOH(\tR\btypeName\DC2\SUB\n\ + \\bextendee\CAN\STX \SOH(\tR\bextendee\DC2#\n\ + \\rdefault_value\CAN\a \SOH(\tR\fdefaultValue\DC2\US\n\ + \\voneof_index\CAN\t \SOH(\ENQR\n\ + \oneofIndex\DC2\ESC\n\ + \\tjson_name\CAN\n\ + \ \SOH(\tR\bjsonName\DC27\n\ + \\aoptions\CAN\b \SOH(\v2\GS.google.protobuf.FieldOptionsR\aoptions\DC2'\n\ + \\SIproto3_optional\CAN\DC1 \SOH(\bR\SOproto3Optional\"\182\STX\n\ + \\EOTType\DC2\SI\n\ + \\vTYPE_DOUBLE\DLE\SOH\DC2\SO\n\ + \\n\ + \TYPE_FLOAT\DLE\STX\DC2\SO\n\ + \\n\ + \TYPE_INT64\DLE\ETX\DC2\SI\n\ + \\vTYPE_UINT64\DLE\EOT\DC2\SO\n\ + \\n\ + \TYPE_INT32\DLE\ENQ\DC2\DLE\n\ + \\fTYPE_FIXED64\DLE\ACK\DC2\DLE\n\ + \\fTYPE_FIXED32\DLE\a\DC2\r\n\ + \\tTYPE_BOOL\DLE\b\DC2\SI\n\ + \\vTYPE_STRING\DLE\t\DC2\SO\n\ + \\n\ + \TYPE_GROUP\DLE\n\ + \\DC2\DLE\n\ + \\fTYPE_MESSAGE\DLE\v\DC2\SO\n\ + \\n\ + \TYPE_BYTES\DLE\f\DC2\SI\n\ + \\vTYPE_UINT32\DLE\r\DC2\r\n\ + \\tTYPE_ENUM\DLE\SO\DC2\DC1\n\ + \\rTYPE_SFIXED32\DLE\SI\DC2\DC1\n\ + \\rTYPE_SFIXED64\DLE\DLE\DC2\SI\n\ + \\vTYPE_SINT32\DLE\DC1\DC2\SI\n\ + \\vTYPE_SINT64\DLE\DC2\"C\n\ + \\ENQLabel\DC2\DC2\n\ + \\SOLABEL_OPTIONAL\DLE\SOH\DC2\DC2\n\ + \\SOLABEL_REPEATED\DLE\ETX\DC2\DC2\n\ + \\SOLABEL_REQUIRED\DLE\STX\"c\n\ + \\DC4OneofDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC27\n\ + \\aoptions\CAN\STX \SOH(\v2\GS.google.protobuf.OneofOptionsR\aoptions\"\227\STX\n\ + \\DC3EnumDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2?\n\ + \\ENQvalue\CAN\STX \ETX(\v2).google.protobuf.EnumValueDescriptorProtoR\ENQvalue\DC26\n\ + \\aoptions\CAN\ETX \SOH(\v2\FS.google.protobuf.EnumOptionsR\aoptions\DC2]\n\ + \\SOreserved_range\CAN\EOT \ETX(\v26.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\DC2#\n\ + \\rreserved_name\CAN\ENQ \ETX(\tR\freservedName\SUB;\n\ + \\DC1EnumReservedRange\DC2\DC4\n\ + \\ENQstart\CAN\SOH \SOH(\ENQR\ENQstart\DC2\DLE\n\ + \\ETXend\CAN\STX \SOH(\ENQR\ETXend\"\131\SOH\n\ + \\CANEnumValueDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\SYN\n\ + \\ACKnumber\CAN\STX \SOH(\ENQR\ACKnumber\DC2;\n\ + \\aoptions\CAN\ETX \SOH(\v2!.google.protobuf.EnumValueOptionsR\aoptions\"\167\SOH\n\ + \\SYNServiceDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2>\n\ + \\ACKmethod\CAN\STX \ETX(\v2&.google.protobuf.MethodDescriptorProtoR\ACKmethod\DC29\n\ + \\aoptions\CAN\ETX \SOH(\v2\US.google.protobuf.ServiceOptionsR\aoptions\"\137\STX\n\ + \\NAKMethodDescriptorProto\DC2\DC2\n\ + \\EOTname\CAN\SOH \SOH(\tR\EOTname\DC2\GS\n\ + \\n\ + \input_type\CAN\STX \SOH(\tR\tinputType\DC2\US\n\ + \\voutput_type\CAN\ETX \SOH(\tR\n\ + \outputType\DC28\n\ + \\aoptions\CAN\EOT \SOH(\v2\RS.google.protobuf.MethodOptionsR\aoptions\DC20\n\ + \\DLEclient_streaming\CAN\ENQ \SOH(\b:\ENQfalseR\SIclientStreaming\DC20\n\ + \\DLEserver_streaming\CAN\ACK \SOH(\b:\ENQfalseR\SIserverStreaming\"\173\t\n\ + \\vFileOptions\DC2!\n\ + \\fjava_package\CAN\SOH \SOH(\tR\vjavaPackage\DC20\n\ + \\DC4java_outer_classname\CAN\b \SOH(\tR\DC2javaOuterClassname\DC25\n\ + \\DC3java_multiple_files\CAN\n\ + \ \SOH(\b:\ENQfalseR\DC1javaMultipleFiles\DC2D\n\ + \\GSjava_generate_equals_and_hash\CAN\DC4 \SOH(\bR\EMjavaGenerateEqualsAndHashB\STX\CAN\SOH\DC2:\n\ + \\SYNjava_string_check_utf8\CAN\ESC \SOH(\b:\ENQfalseR\DC3javaStringCheckUtf8\DC2S\n\ + \\foptimize_for\CAN\t \SOH(\SO2).google.protobuf.FileOptions.OptimizeMode:\ENQSPEEDR\voptimizeFor\DC2\GS\n\ + \\n\ + \go_package\CAN\v \SOH(\tR\tgoPackage\DC25\n\ + \\DC3cc_generic_services\CAN\DLE \SOH(\b:\ENQfalseR\DC1ccGenericServices\DC29\n\ + \\NAKjava_generic_services\CAN\DC1 \SOH(\b:\ENQfalseR\DC3javaGenericServices\DC25\n\ + \\DC3py_generic_services\CAN\DC2 \SOH(\b:\ENQfalseR\DC1pyGenericServices\DC2%\n\ + \\n\ + \deprecated\CAN\ETB \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2.\n\ + \\DLEcc_enable_arenas\CAN\US \SOH(\b:\EOTtrueR\SOccEnableArenas\DC2*\n\ + \\DC1objc_class_prefix\CAN$ \SOH(\tR\SIobjcClassPrefix\DC2)\n\ + \\DLEcsharp_namespace\CAN% \SOH(\tR\SIcsharpNamespace\DC2!\n\ + \\fswift_prefix\CAN' \SOH(\tR\vswiftPrefix\DC2(\n\ + \\DLEphp_class_prefix\CAN( \SOH(\tR\SOphpClassPrefix\DC2#\n\ + \\rphp_namespace\CAN) \SOH(\tR\fphpNamespace\DC24\n\ + \\SYNphp_metadata_namespace\CAN, \SOH(\tR\DC4phpMetadataNamespace\DC2!\n\ + \\fruby_package\CAN- \SOH(\tR\vrubyPackage\DC27\n\ + \\bfeatures\CAN2 \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\":\n\ + \\fOptimizeMode\DC2\t\n\ + \\ENQSPEED\DLE\SOH\DC2\r\n\ + \\tCODE_SIZE\DLE\STX\DC2\DLE\n\ + \\fLITE_RUNTIME\DLE\ETX*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b*\DLE+J\EOT\b&\DLE'R\DC4php_generic_services\"\244\ETX\n\ + \\SOMessageOptions\DC2<\n\ + \\ETBmessage_set_wire_format\CAN\SOH \SOH(\b:\ENQfalseR\DC4messageSetWireFormat\DC2L\n\ + \\USno_standard_descriptor_accessor\CAN\STX \SOH(\b:\ENQfalseR\FSnoStandardDescriptorAccessor\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2\ESC\n\ + \\tmap_entry\CAN\a \SOH(\bR\bmapEntry\DC2V\n\ + \&deprecated_legacy_json_field_conflicts\CAN\v \SOH(\bR\"deprecatedLegacyJsonFieldConflictsB\STX\CAN\SOH\DC27\n\ + \\bfeatures\CAN\f \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\EOT\DLE\ENQJ\EOT\b\ENQ\DLE\ACKJ\EOT\b\ACK\DLE\aJ\EOT\b\b\DLE\tJ\EOT\b\t\DLE\n\ + \\"\157\r\n\ + \\fFieldOptions\DC2A\n\ + \\ENQctype\CAN\SOH \SOH(\SO2#.google.protobuf.FieldOptions.CType:\ACKSTRINGR\ENQctype\DC2\SYN\n\ + \\ACKpacked\CAN\STX \SOH(\bR\ACKpacked\DC2G\n\ + \\ACKjstype\CAN\ACK \SOH(\SO2$.google.protobuf.FieldOptions.JSType:\tJS_NORMALR\ACKjstype\DC2\EM\n\ + \\EOTlazy\CAN\ENQ \SOH(\b:\ENQfalseR\EOTlazy\DC2.\n\ + \\SIunverified_lazy\CAN\SI \SOH(\b:\ENQfalseR\SOunverifiedLazy\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2\EM\n\ + \\EOTweak\CAN\n\ + \ \SOH(\b:\ENQfalseR\EOTweak\DC2(\n\ + \\fdebug_redact\CAN\DLE \SOH(\b:\ENQfalseR\vdebugRedact\DC2K\n\ + \\tretention\CAN\DC1 \SOH(\SO2-.google.protobuf.FieldOptions.OptionRetentionR\tretention\DC2H\n\ + \\atargets\CAN\DC3 \ETX(\SO2..google.protobuf.FieldOptions.OptionTargetTypeR\atargets\DC2W\n\ + \\DLEedition_defaults\CAN\DC4 \ETX(\v2,.google.protobuf.FieldOptions.EditionDefaultR\SIeditionDefaults\DC27\n\ + \\bfeatures\CAN\NAK \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2U\n\ + \\SIfeature_support\CAN\SYN \SOH(\v2,.google.protobuf.FieldOptions.FeatureSupportR\SOfeatureSupport\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\SUBZ\n\ + \\SOEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2\DC4\n\ + \\ENQvalue\CAN\STX \SOH(\tR\ENQvalue\SUB\150\STX\n\ + \\SOFeatureSupport\DC2G\n\ + \\DC2edition_introduced\CAN\SOH \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionIntroduced\DC2G\n\ + \\DC2edition_deprecated\CAN\STX \SOH(\SO2\CAN.google.protobuf.EditionR\DC1editionDeprecated\DC2/\n\ + \\DC3deprecation_warning\CAN\ETX \SOH(\tR\DC2deprecationWarning\DC2A\n\ + \\SIedition_removed\CAN\EOT \SOH(\SO2\CAN.google.protobuf.EditionR\SOeditionRemoved\"/\n\ + \\ENQCType\DC2\n\ + \\n\ + \\ACKSTRING\DLE\NUL\DC2\b\n\ + \\EOTCORD\DLE\SOH\DC2\DLE\n\ + \\fSTRING_PIECE\DLE\STX\"5\n\ + \\ACKJSType\DC2\r\n\ + \\tJS_NORMAL\DLE\NUL\DC2\r\n\ + \\tJS_STRING\DLE\SOH\DC2\r\n\ + \\tJS_NUMBER\DLE\STX\"U\n\ + \\SIOptionRetention\DC2\NAK\n\ + \\DC1RETENTION_UNKNOWN\DLE\NUL\DC2\NAK\n\ + \\DC1RETENTION_RUNTIME\DLE\SOH\DC2\DC4\n\ + \\DLERETENTION_SOURCE\DLE\STX\"\140\STX\n\ + \\DLEOptionTargetType\DC2\ETB\n\ + \\DC3TARGET_TYPE_UNKNOWN\DLE\NUL\DC2\DC4\n\ + \\DLETARGET_TYPE_FILE\DLE\SOH\DC2\US\n\ + \\ESCTARGET_TYPE_EXTENSION_RANGE\DLE\STX\DC2\ETB\n\ + \\DC3TARGET_TYPE_MESSAGE\DLE\ETX\DC2\NAK\n\ + \\DC1TARGET_TYPE_FIELD\DLE\EOT\DC2\NAK\n\ + \\DC1TARGET_TYPE_ONEOF\DLE\ENQ\DC2\DC4\n\ + \\DLETARGET_TYPE_ENUM\DLE\ACK\DC2\SUB\n\ + \\SYNTARGET_TYPE_ENUM_ENTRY\DLE\a\DC2\ETB\n\ + \\DC3TARGET_TYPE_SERVICE\DLE\b\DC2\SYN\n\ + \\DC2TARGET_TYPE_METHOD\DLE\t*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\EOT\DLE\ENQJ\EOT\b\DC2\DLE\DC3\"\172\SOH\n\ + \\fOneofOptions\DC27\n\ + \\bfeatures\CAN\SOH \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX\"\209\STX\n\ + \\vEnumOptions\DC2\US\n\ + \\vallow_alias\CAN\STX \SOH(\bR\n\ + \allowAlias\DC2%\n\ + \\n\ + \deprecated\CAN\ETX \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2V\n\ + \&deprecated_legacy_json_field_conflicts\CAN\ACK \SOH(\bR\"deprecatedLegacyJsonFieldConflictsB\STX\CAN\SOH\DC27\n\ + \\bfeatures\CAN\a \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STXJ\EOT\b\ENQ\DLE\ACK\"\216\STX\n\ + \\DLEEnumValueOptions\DC2%\n\ + \\n\ + \deprecated\CAN\SOH \SOH(\b:\ENQfalseR\n\ + \deprecated\DC27\n\ + \\bfeatures\CAN\STX \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2(\n\ + \\fdebug_redact\CAN\ETX \SOH(\b:\ENQfalseR\vdebugRedact\DC2U\n\ + \\SIfeature_support\CAN\EOT \SOH(\v2,.google.protobuf.FieldOptions.FeatureSupportR\SOfeatureSupport\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX\"\213\SOH\n\ + \\SOServiceOptions\DC27\n\ + \\bfeatures\CAN\" \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2%\n\ + \\n\ + \deprecated\CAN! \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption*\t\b\232\a\DLE\128\128\128\128\STX\"\153\ETX\n\ + \\rMethodOptions\DC2%\n\ + \\n\ + \deprecated\CAN! \SOH(\b:\ENQfalseR\n\ + \deprecated\DC2q\n\ + \\DC1idempotency_level\CAN\" \SOH(\SO2/.google.protobuf.MethodOptions.IdempotencyLevel:\DC3IDEMPOTENCY_UNKNOWNR\DLEidempotencyLevel\DC27\n\ + \\bfeatures\CAN# \SOH(\v2\ESC.google.protobuf.FeatureSetR\bfeatures\DC2X\n\ + \\DC4uninterpreted_option\CAN\231\a \ETX(\v2$.google.protobuf.UninterpretedOptionR\DC3uninterpretedOption\"P\n\ + \\DLEIdempotencyLevel\DC2\ETB\n\ + \\DC3IDEMPOTENCY_UNKNOWN\DLE\NUL\DC2\DC3\n\ + \\SINO_SIDE_EFFECTS\DLE\SOH\DC2\SO\n\ + \\n\ + \IDEMPOTENT\DLE\STX*\t\b\232\a\DLE\128\128\128\128\STX\"\154\ETX\n\ + \\DC3UninterpretedOption\DC2A\n\ + \\EOTname\CAN\STX \ETX(\v2-.google.protobuf.UninterpretedOption.NamePartR\EOTname\DC2)\n\ + \\DLEidentifier_value\CAN\ETX \SOH(\tR\SIidentifierValue\DC2,\n\ + \\DC2positive_int_value\CAN\EOT \SOH(\EOTR\DLEpositiveIntValue\DC2,\n\ + \\DC2negative_int_value\CAN\ENQ \SOH(\ETXR\DLEnegativeIntValue\DC2!\n\ + \\fdouble_value\CAN\ACK \SOH(\SOHR\vdoubleValue\DC2!\n\ + \\fstring_value\CAN\a \SOH(\fR\vstringValue\DC2'\n\ + \\SIaggregate_value\CAN\b \SOH(\tR\SOaggregateValue\SUBJ\n\ + \\bNamePart\DC2\ESC\n\ + \\tname_part\CAN\SOH \STX(\tR\bnamePart\DC2!\n\ + \\fis_extension\CAN\STX \STX(\bR\visExtension\"\167\n\ + \\n\ + \\n\ + \FeatureSet\DC2\145\SOH\n\ + \\SOfield_presence\CAN\SOH \SOH(\SO2).google.protobuf.FeatureSet.FieldPresenceR\rfieldPresenceB?\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\r\DC2\bEXPLICIT\CAN\132\a\162\SOH\r\DC2\bIMPLICIT\CAN\231\a\162\SOH\r\DC2\bEXPLICIT\CAN\232\a\178\SOH\ETX\b\232\a\DC2l\n\ + \\tenum_type\CAN\STX \SOH(\SO2$.google.protobuf.FeatureSet.EnumTypeR\benumTypeB)\136\SOH\SOH\152\SOH\ACK\152\SOH\SOH\162\SOH\v\DC2\ACKCLOSED\CAN\132\a\162\SOH\t\DC2\EOTOPEN\CAN\231\a\178\SOH\ETX\b\232\a\DC2\152\SOH\n\ + \\ETBrepeated_field_encoding\CAN\ETX \SOH(\SO21.google.protobuf.FeatureSet.RepeatedFieldEncodingR\NAKrepeatedFieldEncodingB-\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\r\DC2\bEXPANDED\CAN\132\a\162\SOH\v\DC2\ACKPACKED\CAN\231\a\178\SOH\ETX\b\232\a\DC2~\n\ + \\SIutf8_validation\CAN\EOT \SOH(\SO2*.google.protobuf.FeatureSet.Utf8ValidationR\SOutf8ValidationB)\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\t\DC2\EOTNONE\CAN\132\a\162\SOH\v\DC2\ACKVERIFY\CAN\231\a\178\SOH\ETX\b\232\a\DC2~\n\ + \\DLEmessage_encoding\CAN\ENQ \SOH(\SO2+.google.protobuf.FeatureSet.MessageEncodingR\SImessageEncodingB&\136\SOH\SOH\152\SOH\EOT\152\SOH\SOH\162\SOH\DC4\DC2\SILENGTH_PREFIXED\CAN\132\a\178\SOH\ETX\b\232\a\DC2\130\SOH\n\ + \\vjson_format\CAN\ACK \SOH(\SO2&.google.protobuf.FeatureSet.JsonFormatR\n\ + \jsonFormatB9\136\SOH\SOH\152\SOH\ETX\152\SOH\ACK\152\SOH\SOH\162\SOH\ETB\DC2\DC2LEGACY_BEST_EFFORT\CAN\132\a\162\SOH\n\ + \\DC2\ENQALLOW\CAN\231\a\178\SOH\ETX\b\232\a\"\\\n\ + \\rFieldPresence\DC2\SUB\n\ + \\SYNFIELD_PRESENCE_UNKNOWN\DLE\NUL\DC2\f\n\ + \\bEXPLICIT\DLE\SOH\DC2\f\n\ + \\bIMPLICIT\DLE\STX\DC2\DC3\n\ + \\SILEGACY_REQUIRED\DLE\ETX\"7\n\ + \\bEnumType\DC2\NAK\n\ + \\DC1ENUM_TYPE_UNKNOWN\DLE\NUL\DC2\b\n\ + \\EOTOPEN\DLE\SOH\DC2\n\ + \\n\ + \\ACKCLOSED\DLE\STX\"V\n\ + \\NAKRepeatedFieldEncoding\DC2#\n\ + \\USREPEATED_FIELD_ENCODING_UNKNOWN\DLE\NUL\DC2\n\ + \\n\ + \\ACKPACKED\DLE\SOH\DC2\f\n\ + \\bEXPANDED\DLE\STX\"I\n\ + \\SOUtf8Validation\DC2\ESC\n\ + \\ETBUTF8_VALIDATION_UNKNOWN\DLE\NUL\DC2\n\ + \\n\ + \\ACKVERIFY\DLE\STX\DC2\b\n\ + \\EOTNONE\DLE\ETX\"\EOT\b\SOH\DLE\SOH\"S\n\ + \\SIMessageEncoding\DC2\FS\n\ + \\CANMESSAGE_ENCODING_UNKNOWN\DLE\NUL\DC2\DC3\n\ + \\SILENGTH_PREFIXED\DLE\SOH\DC2\r\n\ + \\tDELIMITED\DLE\STX\"H\n\ + \\n\ + \JsonFormat\DC2\ETB\n\ + \\DC3JSON_FORMAT_UNKNOWN\DLE\NUL\DC2\t\n\ + \\ENQALLOW\DLE\SOH\DC2\SYN\n\ + \\DC2LEGACY_BEST_EFFORT\DLE\STX*\ACK\b\232\a\DLE\139N*\ACK\b\139N\DLE\144N*\ACK\b\144N\DLE\145NJ\ACK\b\231\a\DLE\232\a\"\239\ETX\n\ + \\DC2FeatureSetDefaults\DC2X\n\ + \\bdefaults\CAN\SOH \ETX(\v2<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\bdefaults\DC2A\n\ + \\SIminimum_edition\CAN\EOT \SOH(\SO2\CAN.google.protobuf.EditionR\SOminimumEdition\DC2A\n\ + \\SImaximum_edition\CAN\ENQ \SOH(\SO2\CAN.google.protobuf.EditionR\SOmaximumEdition\SUB\248\SOH\n\ + \\CANFeatureSetEditionDefault\DC22\n\ + \\aedition\CAN\ETX \SOH(\SO2\CAN.google.protobuf.EditionR\aedition\DC2N\n\ + \\DC4overridable_features\CAN\EOT \SOH(\v2\ESC.google.protobuf.FeatureSetR\DC3overridableFeatures\DC2B\n\ + \\SOfixed_features\CAN\ENQ \SOH(\v2\ESC.google.protobuf.FeatureSetR\rfixedFeaturesJ\EOT\b\SOH\DLE\STXJ\EOT\b\STX\DLE\ETXR\bfeatures\"\167\STX\n\ + \\SOSourceCodeInfo\DC2D\n\ + \\blocation\CAN\SOH \ETX(\v2(.google.protobuf.SourceCodeInfo.LocationR\blocation\SUB\206\SOH\n\ + \\bLocation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\SYN\n\ + \\EOTspan\CAN\STX \ETX(\ENQR\EOTspanB\STX\DLE\SOH\DC2)\n\ + \\DLEleading_comments\CAN\ETX \SOH(\tR\SIleadingComments\DC2+\n\ + \\DC1trailing_comments\CAN\EOT \SOH(\tR\DLEtrailingComments\DC2:\n\ + \\EMleading_detached_comments\CAN\ACK \ETX(\tR\ETBleadingDetachedComments\"\208\STX\n\ + \\DC1GeneratedCodeInfo\DC2M\n\ + \\n\ + \annotation\CAN\SOH \ETX(\v2-.google.protobuf.GeneratedCodeInfo.AnnotationR\n\ + \annotation\SUB\235\SOH\n\ + \\n\ + \Annotation\DC2\SYN\n\ + \\EOTpath\CAN\SOH \ETX(\ENQR\EOTpathB\STX\DLE\SOH\DC2\US\n\ + \\vsource_file\CAN\STX \SOH(\tR\n\ + \sourceFile\DC2\DC4\n\ + \\ENQbegin\CAN\ETX \SOH(\ENQR\ENQbegin\DC2\DLE\n\ + \\ETXend\CAN\EOT \SOH(\ENQR\ETXend\DC2R\n\ + \\bsemantic\CAN\ENQ \SOH(\SO26.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\bsemantic\"(\n\ + \\bSemantic\DC2\b\n\ + \\EOTNONE\DLE\NUL\DC2\a\n\ + \\ETXSET\DLE\SOH\DC2\t\n\ + \\ENQALIAS\DLE\STX*\167\STX\n\ + \\aEdition\DC2\DC3\n\ + \\SIEDITION_UNKNOWN\DLE\NUL\DC2\DC3\n\ + \\SOEDITION_LEGACY\DLE\132\a\DC2\DC3\n\ + \\SOEDITION_PROTO2\DLE\230\a\DC2\DC3\n\ + \\SOEDITION_PROTO3\DLE\231\a\DC2\DC1\n\ + \\fEDITION_2023\DLE\232\a\DC2\DC1\n\ + \\fEDITION_2024\DLE\233\a\DC2\ETB\n\ + \\DC3EDITION_1_TEST_ONLY\DLE\SOH\DC2\ETB\n\ + \\DC3EDITION_2_TEST_ONLY\DLE\STX\DC2\GS\n\ + \\ETBEDITION_99997_TEST_ONLY\DLE\157\141\ACK\DC2\GS\n\ + \\ETBEDITION_99998_TEST_ONLY\DLE\158\141\ACK\DC2\GS\n\ + \\ETBEDITION_99999_TEST_ONLY\DLE\159\141\ACK\DC2\DC3\n\ + \\vEDITION_MAX\DLE\255\255\255\255\aB~\n\ + \\DC3com.google.protobufB\DLEDescriptorProtosH\SOHZ-google.golang.org/protobuf/types/descriptorpb\248\SOH\SOH\162\STX\ETXGPB\170\STX\SUBGoogle.Protobuf.ReflectionJ\139\195\ETX\n\ + \\a\DC2\ENQ&\NUL\143\n\ + \\SOH\n\ + \\170\SI\n\ + \\SOH\f\DC2\ETX&\NUL\DC22\193\f Protocol Buffers - Google's data interchange format\n\ + \ Copyright 2008 Google Inc. All rights reserved.\n\ + \ https://developers.google.com/protocol-buffers/\n\ + \\n\ + \ Redistribution and use in source and binary forms, with or without\n\ + \ modification, are permitted provided that the following conditions are\n\ + \ met:\n\ + \\n\ + \ * Redistributions of source code must retain the above copyright\n\ + \ notice, this list of conditions and the following disclaimer.\n\ + \ * Redistributions in binary form must reproduce the above\n\ + \ copyright notice, this list of conditions and the following disclaimer\n\ + \ in the documentation and/or other materials provided with the\n\ + \ distribution.\n\ + \ * Neither the name of Google Inc. nor the names of its\n\ + \ contributors may be used to endorse or promote products derived from\n\ + \ this software without specific prior written permission.\n\ + \\n\ + \ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\ + \ \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n\ + \ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\ + \ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n\ + \ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n\ + \ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n\ + \ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n\ + \ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n\ + \ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n\ + \ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n\ + \ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\ + \2\219\STX Author: kenton@google.com (Kenton Varda)\n\ + \ Based on original Protocol Buffers design by\n\ + \ Sanjay Ghemawat, Jeff Dean, and others.\n\ + \\n\ + \ The messages in this file describe the definitions found in .proto files.\n\ + \ A valid .proto file can be translated directly to a FileDescriptorProto\n\ + \ without any other information (e.g. without reading its imports).\n\ + \\n\ + \\b\n\ + \\SOH\STX\DC2\ETX(\NUL\CAN\n\ + \\b\n\ + \\SOH\b\DC2\ETX*\NULD\n\ + \\t\n\ + \\STX\b\v\DC2\ETX*\NULD\n\ + \\b\n\ + \\SOH\b\DC2\ETX+\NUL,\n\ + \\t\n\ + \\STX\b\SOH\DC2\ETX+\NUL,\n\ + \\b\n\ + \\SOH\b\DC2\ETX,\NUL1\n\ + \\t\n\ + \\STX\b\b\DC2\ETX,\NUL1\n\ + \\b\n\ + \\SOH\b\DC2\ETX-\NUL7\n\ + \\t\n\ + \\STX\b%\DC2\ETX-\NUL7\n\ + \\b\n\ + \\SOH\b\DC2\ETX.\NUL!\n\ + \\t\n\ + \\STX\b$\DC2\ETX.\NUL!\n\ + \\b\n\ + \\SOH\b\DC2\ETX/\NUL\US\n\ + \\t\n\ + \\STX\b\US\DC2\ETX/\NUL\US\n\ + \\b\n\ + \\SOH\b\DC2\ETX3\NUL\FS\n\ + \\DEL\n\ + \\STX\b\t\DC2\ETX3\NUL\FS\SUBt descriptor.proto must be optimized for speed because reflection-based\n\ + \ algorithms don't work during bootstrapping.\n\ + \\n\ + \j\n\ + \\STX\EOT\NUL\DC2\EOT7\NUL9\SOH\SUB^ The protocol compiler can output a FileDescriptorSet containing the .proto\n\ + \ files it parses.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\EOT\NUL\SOH\DC2\ETX7\b\EM\n\ + \\v\n\ + \\EOT\EOT\NUL\STX\NUL\DC2\ETX8\STX(\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\EOT\DC2\ETX8\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\ACK\DC2\ETX8\v\RS\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\ETX8\US#\n\ + \\f\n\ + \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\ETX8&'\n\ + \-\n\ + \\STX\ENQ\NUL\DC2\EOT<\NUL]\SOH\SUB! The full set of known editions.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\ENQ\NUL\SOH\DC2\ETX<\ENQ\f\n\ + \:\n\ + \\EOT\ENQ\NUL\STX\NUL\DC2\ETX>\STX\SYN\SUB- A placeholder for an unknown edition value.\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\NUL\SOH\DC2\ETX>\STX\DC1\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\NUL\STX\DC2\ETX>\DC4\NAK\n\ + \\153\SOH\n\ + \\EOT\ENQ\NUL\STX\SOH\DC2\ETXB\STX\ETB\SUB\139\SOH A placeholder edition for specifying default behaviors *before* a feature\n\ + \ was first introduced. This is effectively an \"infinite past\".\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\SOH\SOH\DC2\ETXB\STX\DLE\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\SOH\STX\DC2\ETXB\DC3\SYN\n\ + \\130\STX\n\ + \\EOT\ENQ\NUL\STX\STX\DC2\ETXH\STX\ETB\SUB\244\SOH Legacy syntax \"editions\". These pre-date editions, but behave much like\n\ + \ distinct editions. These can't be used to specify the edition of proto\n\ + \ files, but feature definitions must supply proto2/proto3 defaults for\n\ + \ backwards compatibility.\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\STX\SOH\DC2\ETXH\STX\DLE\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\STX\STX\DC2\ETXH\DC3\SYN\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\ETX\DC2\ETXI\STX\ETB\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ETX\SOH\DC2\ETXI\STX\DLE\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ETX\STX\DC2\ETXI\DC3\SYN\n\ + \\175\SOH\n\ + \\EOT\ENQ\NUL\STX\EOT\DC2\ETXN\STX\SYN\SUB\161\SOH Editions that have been released. The specific values are arbitrary and\n\ + \ should not be depended on, but they will always be time-ordered for easy\n\ + \ comparison.\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\EOT\SOH\DC2\ETXN\STX\SO\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\EOT\STX\DC2\ETXN\DC1\NAK\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\ENQ\DC2\ETXO\STX\SYN\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ENQ\SOH\DC2\ETXO\STX\SO\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ENQ\STX\DC2\ETXO\DC1\NAK\n\ + \}\n\ + \\EOT\ENQ\NUL\STX\ACK\DC2\ETXS\STX\SUB\SUBp Placeholder editions for testing feature resolution. These should not be\n\ + \ used or relyed on outside of tests.\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ACK\SOH\DC2\ETXS\STX\NAK\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\ACK\STX\DC2\ETXS\CAN\EM\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\a\DC2\ETXT\STX\SUB\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\a\SOH\DC2\ETXT\STX\NAK\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\a\STX\DC2\ETXT\CAN\EM\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\b\DC2\ETXU\STX\"\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\b\SOH\DC2\ETXU\STX\EM\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\b\STX\DC2\ETXU\FS!\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\t\DC2\ETXV\STX\"\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\t\SOH\DC2\ETXV\STX\EM\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\t\STX\DC2\ETXV\FS!\n\ + \\v\n\ + \\EOT\ENQ\NUL\STX\n\ + \\DC2\ETXW\STX\"\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\n\ + \\SOH\DC2\ETXW\STX\EM\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\n\ + \\STX\DC2\ETXW\FS!\n\ + \\184\SOH\n\ + \\EOT\ENQ\NUL\STX\v\DC2\ETX\\\STX\ESC\SUB\170\SOH Placeholder for specifying unbounded edition support. This should only\n\ + \ ever be used by plugins that can expect to never require any changes to\n\ + \ support a new edition.\n\ + \\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\v\SOH\DC2\ETX\\\STX\r\n\ + \\f\n\ + \\ENQ\ENQ\NUL\STX\v\STX\DC2\ETX\\\DLE\SUB\n\ + \0\n\ + \\STX\EOT\SOH\DC2\ENQ`\NUL\130\SOH\SOH\SUB# Describes a complete .proto file.\n\ + \\n\ + \\n\ + \\n\ + \\ETX\EOT\SOH\SOH\DC2\ETX`\b\ESC\n\ + \9\n\ + \\EOT\EOT\SOH\STX\NUL\DC2\ETXa\STX\ESC\", file name, relative to root of source tree\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\EOT\DC2\ETXa\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\ENQ\DC2\ETXa\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\SOH\DC2\ETXa\DC2\SYN\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\NUL\ETX\DC2\ETXa\EM\SUB\n\ + \*\n\ + \\EOT\EOT\SOH\STX\SOH\DC2\ETXb\STX\RS\"\GS e.g. \"foo\", \"foo.bar\", etc.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\EOT\DC2\ETXb\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\ENQ\DC2\ETXb\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\SOH\DC2\ETXb\DC2\EM\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\SOH\ETX\DC2\ETXb\FS\GS\n\ + \4\n\ + \\EOT\EOT\SOH\STX\STX\DC2\ETXe\STX!\SUB' Names of files imported by this file.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\EOT\DC2\ETXe\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\ENQ\DC2\ETXe\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\SOH\DC2\ETXe\DC2\FS\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\STX\ETX\DC2\ETXe\US \n\ + \Q\n\ + \\EOT\EOT\SOH\STX\ETX\DC2\ETXg\STX(\SUBD Indexes of the public imported files in the dependency list above.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\EOT\DC2\ETXg\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\ENQ\DC2\ETXg\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\SOH\DC2\ETXg\DC1\"\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ETX\ETX\DC2\ETXg%'\n\ + \z\n\ + \\EOT\EOT\SOH\STX\EOT\DC2\ETXj\STX&\SUBm Indexes of the weak imported files in the dependency list.\n\ + \ For Google-internal migration only. Do not use.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\EOT\DC2\ETXj\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\ENQ\DC2\ETXj\v\DLE\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\SOH\DC2\ETXj\DC1 \n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\EOT\ETX\DC2\ETXj#%\n\ + \6\n\ + \\EOT\EOT\SOH\STX\ENQ\DC2\ETXm\STX,\SUB) All top-level definitions in this file.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ENQ\EOT\DC2\ETXm\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ENQ\ACK\DC2\ETXm\v\SUB\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ENQ\SOH\DC2\ETXm\ESC'\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ENQ\ETX\DC2\ETXm*+\n\ + \\v\n\ + \\EOT\EOT\SOH\STX\ACK\DC2\ETXn\STX-\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ACK\EOT\DC2\ETXn\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ACK\ACK\DC2\ETXn\v\RS\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ACK\SOH\DC2\ETXn\US(\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\ACK\ETX\DC2\ETXn+,\n\ + \\v\n\ + \\EOT\EOT\SOH\STX\a\DC2\ETXo\STX.\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\a\EOT\DC2\ETXo\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\a\ACK\DC2\ETXo\v!\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\a\SOH\DC2\ETXo\")\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\a\ETX\DC2\ETXo,-\n\ + \\v\n\ + \\EOT\EOT\SOH\STX\b\DC2\ETXp\STX.\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\b\EOT\DC2\ETXp\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\b\ACK\DC2\ETXp\v\US\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\b\SOH\DC2\ETXp )\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\b\ETX\DC2\ETXp,-\n\ + \\v\n\ + \\EOT\EOT\SOH\STX\t\DC2\ETXr\STX#\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\t\EOT\DC2\ETXr\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\t\ACK\DC2\ETXr\v\SYN\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\t\SOH\DC2\ETXr\ETB\RS\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\t\ETX\DC2\ETXr!\"\n\ + \\244\SOH\n\ + \\EOT\EOT\SOH\STX\n\ + \\DC2\ETXx\STX/\SUB\230\SOH This field contains optional information about the original source code.\n\ + \ You may safely remove this entire field without harming runtime\n\ + \ functionality of the descriptors -- the information is needed only by\n\ + \ development tools.\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\n\ + \\EOT\DC2\ETXx\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\n\ + \\ACK\DC2\ETXx\v\EM\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\n\ + \\SOH\DC2\ETXx\SUB*\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\n\ + \\ETX\DC2\ETXx-.\n\ + \\165\SOH\n\ + \\EOT\EOT\SOH\STX\v\DC2\ETX~\STX\RS\SUB\151\SOH The syntax of the proto file.\n\ + \ The supported values are \"proto2\", \"proto3\", and \"editions\".\n\ + \\n\ + \ If `edition` is present, this value must be \"editions\".\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\v\EOT\DC2\ETX~\STX\n\ + \\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\v\ENQ\DC2\ETX~\v\DC1\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\v\SOH\DC2\ETX~\DC2\CAN\n\ + \\f\n\ + \\ENQ\EOT\SOH\STX\v\ETX\DC2\ETX~\ESC\GS\n\ + \.\n\ + \\EOT\EOT\SOH\STX\f\DC2\EOT\129\SOH\STX \SUB The edition of the proto file.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\SOH\STX\f\EOT\DC2\EOT\129\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\SOH\STX\f\ACK\DC2\EOT\129\SOH\v\DC2\n\ + \\r\n\ + \\ENQ\EOT\SOH\STX\f\SOH\DC2\EOT\129\SOH\DC3\SUB\n\ + \\r\n\ + \\ENQ\EOT\SOH\STX\f\ETX\DC2\EOT\129\SOH\GS\US\n\ + \)\n\ + \\STX\EOT\STX\DC2\ACK\133\SOH\NUL\165\SOH\SOH\SUB\ESC Describes a message type.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\STX\SOH\DC2\EOT\133\SOH\b\ETB\n\ + \\f\n\ + \\EOT\EOT\STX\STX\NUL\DC2\EOT\134\SOH\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\NUL\EOT\DC2\EOT\134\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\NUL\ENQ\DC2\EOT\134\SOH\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\NUL\SOH\DC2\EOT\134\SOH\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\NUL\ETX\DC2\EOT\134\SOH\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\STX\STX\SOH\DC2\EOT\136\SOH\STX*\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\SOH\EOT\DC2\EOT\136\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\SOH\ACK\DC2\EOT\136\SOH\v\US\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\SOH\SOH\DC2\EOT\136\SOH %\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\SOH\ETX\DC2\EOT\136\SOH()\n\ + \\f\n\ + \\EOT\EOT\STX\STX\STX\DC2\EOT\137\SOH\STX.\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\STX\EOT\DC2\EOT\137\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\STX\ACK\DC2\EOT\137\SOH\v\US\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\STX\SOH\DC2\EOT\137\SOH )\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\STX\ETX\DC2\EOT\137\SOH,-\n\ + \\f\n\ + \\EOT\EOT\STX\STX\ETX\DC2\EOT\139\SOH\STX+\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ETX\EOT\DC2\EOT\139\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ETX\ACK\DC2\EOT\139\SOH\v\SUB\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ETX\SOH\DC2\EOT\139\SOH\ESC&\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ETX\ETX\DC2\EOT\139\SOH)*\n\ + \\f\n\ + \\EOT\EOT\STX\STX\EOT\DC2\EOT\140\SOH\STX-\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\EOT\DC2\EOT\140\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\ACK\DC2\EOT\140\SOH\v\RS\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\SOH\DC2\EOT\140\SOH\US(\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\EOT\ETX\DC2\EOT\140\SOH+,\n\ + \\SO\n\ + \\EOT\EOT\STX\ETX\NUL\DC2\ACK\142\SOH\STX\147\SOH\ETX\n\ + \\r\n\ + \\ENQ\EOT\STX\ETX\NUL\SOH\DC2\EOT\142\SOH\n\ + \\CAN\n\ + \\FS\n\ + \\ACK\EOT\STX\ETX\NUL\STX\NUL\DC2\EOT\143\SOH\EOT\GS\"\f Inclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\EOT\DC2\EOT\143\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\ENQ\DC2\EOT\143\SOH\r\DC2\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\SOH\DC2\EOT\143\SOH\DC3\CAN\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\NUL\ETX\DC2\EOT\143\SOH\ESC\FS\n\ + \\FS\n\ + \\ACK\EOT\STX\ETX\NUL\STX\SOH\DC2\EOT\144\SOH\EOT\ESC\"\f Exclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\EOT\DC2\EOT\144\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\ENQ\DC2\EOT\144\SOH\r\DC2\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\SOH\DC2\EOT\144\SOH\DC3\SYN\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\SOH\ETX\DC2\EOT\144\SOH\EM\SUB\n\ + \\SO\n\ + \\ACK\EOT\STX\ETX\NUL\STX\STX\DC2\EOT\146\SOH\EOT/\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\EOT\DC2\EOT\146\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\ACK\DC2\EOT\146\SOH\r\"\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\SOH\DC2\EOT\146\SOH#*\n\ + \\SI\n\ + \\a\EOT\STX\ETX\NUL\STX\STX\ETX\DC2\EOT\146\SOH-.\n\ + \\f\n\ + \\EOT\EOT\STX\STX\ENQ\DC2\EOT\148\SOH\STX.\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ENQ\EOT\DC2\EOT\148\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ENQ\ACK\DC2\EOT\148\SOH\v\EM\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ENQ\SOH\DC2\EOT\148\SOH\SUB)\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ENQ\ETX\DC2\EOT\148\SOH,-\n\ + \\f\n\ + \\EOT\EOT\STX\STX\ACK\DC2\EOT\150\SOH\STX/\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ACK\EOT\DC2\EOT\150\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ACK\ACK\DC2\EOT\150\SOH\v\US\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ACK\SOH\DC2\EOT\150\SOH *\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\ACK\ETX\DC2\EOT\150\SOH-.\n\ + \\f\n\ + \\EOT\EOT\STX\STX\a\DC2\EOT\152\SOH\STX&\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\a\EOT\DC2\EOT\152\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\a\ACK\DC2\EOT\152\SOH\v\EM\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\a\SOH\DC2\EOT\152\SOH\SUB!\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\a\ETX\DC2\EOT\152\SOH$%\n\ + \\172\SOH\n\ + \\EOT\EOT\STX\ETX\SOH\DC2\ACK\157\SOH\STX\160\SOH\ETX\SUB\155\SOH Range of reserved tag numbers. Reserved tag numbers may not be used by\n\ + \ fields or extension ranges in the same message. Reserved ranges may\n\ + \ not overlap.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\ETX\SOH\SOH\DC2\EOT\157\SOH\n\ + \\ETB\n\ + \\FS\n\ + \\ACK\EOT\STX\ETX\SOH\STX\NUL\DC2\EOT\158\SOH\EOT\GS\"\f Inclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\NUL\EOT\DC2\EOT\158\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\NUL\ENQ\DC2\EOT\158\SOH\r\DC2\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\NUL\SOH\DC2\EOT\158\SOH\DC3\CAN\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\NUL\ETX\DC2\EOT\158\SOH\ESC\FS\n\ + \\FS\n\ + \\ACK\EOT\STX\ETX\SOH\STX\SOH\DC2\EOT\159\SOH\EOT\ESC\"\f Exclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\SOH\EOT\DC2\EOT\159\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\SOH\ENQ\DC2\EOT\159\SOH\r\DC2\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\SOH\SOH\DC2\EOT\159\SOH\DC3\SYN\n\ + \\SI\n\ + \\a\EOT\STX\ETX\SOH\STX\SOH\ETX\DC2\EOT\159\SOH\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\STX\STX\b\DC2\EOT\161\SOH\STX,\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\b\EOT\DC2\EOT\161\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\b\ACK\DC2\EOT\161\SOH\v\CAN\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\b\SOH\DC2\EOT\161\SOH\EM'\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\b\ETX\DC2\EOT\161\SOH*+\n\ + \\131\SOH\n\ + \\EOT\EOT\STX\STX\t\DC2\EOT\164\SOH\STX%\SUBu Reserved field names, which may not be used by fields in the same message.\n\ + \ A given name may only be reserved once.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\t\EOT\DC2\EOT\164\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\t\ENQ\DC2\EOT\164\SOH\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\t\SOH\DC2\EOT\164\SOH\DC2\US\n\ + \\r\n\ + \\ENQ\EOT\STX\STX\t\ETX\DC2\EOT\164\SOH\"$\n\ + \\f\n\ + \\STX\EOT\ETX\DC2\ACK\167\SOH\NUL\219\SOH\SOH\n\ + \\v\n\ + \\ETX\EOT\ETX\SOH\DC2\EOT\167\SOH\b\GS\n\ + \O\n\ + \\EOT\EOT\ETX\STX\NUL\DC2\EOT\169\SOH\STX:\SUBA The parser stores options it doesn't recognize here. See above.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\NUL\EOT\DC2\EOT\169\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\NUL\ACK\DC2\EOT\169\SOH\v\RS\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\NUL\SOH\DC2\EOT\169\SOH\US3\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\NUL\ETX\DC2\EOT\169\SOH69\n\ + \\SO\n\ + \\EOT\EOT\ETX\ETX\NUL\DC2\ACK\171\SOH\STX\194\SOH\ETX\n\ + \\r\n\ + \\ENQ\EOT\ETX\ETX\NUL\SOH\DC2\EOT\171\SOH\n\ + \\NAK\n\ + \K\n\ + \\ACK\EOT\ETX\ETX\NUL\STX\NUL\DC2\EOT\173\SOH\EOT\RS\SUB; The extension number declared within the extension range.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\NUL\EOT\DC2\EOT\173\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\NUL\ENQ\DC2\EOT\173\SOH\r\DC2\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\NUL\SOH\DC2\EOT\173\SOH\DC3\EM\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\NUL\ETX\DC2\EOT\173\SOH\FS\GS\n\ + \z\n\ + \\ACK\EOT\ETX\ETX\NUL\STX\SOH\DC2\EOT\177\SOH\EOT\"\SUBj The fully-qualified name of the extension field. There must be a leading\n\ + \ dot in front of the full name.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\SOH\EOT\DC2\EOT\177\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\SOH\ENQ\DC2\EOT\177\SOH\r\DC3\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\SOH\SOH\DC2\EOT\177\SOH\DC4\GS\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\SOH\ETX\DC2\EOT\177\SOH !\n\ + \\161\SOH\n\ + \\ACK\EOT\ETX\ETX\NUL\STX\STX\DC2\EOT\182\SOH\EOT\GS\SUB\144\SOH The fully-qualified type name of the extension field. Unlike\n\ + \ Metadata.type, Declaration.type must have a leading dot for messages\n\ + \ and enums.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\STX\EOT\DC2\EOT\182\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\STX\ENQ\DC2\EOT\182\SOH\r\DC3\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\STX\SOH\DC2\EOT\182\SOH\DC4\CAN\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\STX\ETX\DC2\EOT\182\SOH\ESC\FS\n\ + \\206\SOH\n\ + \\ACK\EOT\ETX\ETX\NUL\STX\ETX\DC2\EOT\187\SOH\EOT\US\SUB\189\SOH If true, indicates that the number is reserved in the extension range,\n\ + \ and any extension field with the number will fail to compile. Set this\n\ + \ when a declared extension field is deleted.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\ETX\EOT\DC2\EOT\187\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\ETX\ENQ\DC2\EOT\187\SOH\r\DC1\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\ETX\SOH\DC2\EOT\187\SOH\DC2\SUB\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\ETX\ETX\DC2\EOT\187\SOH\GS\RS\n\ + \\138\SOH\n\ + \\ACK\EOT\ETX\ETX\NUL\STX\EOT\DC2\EOT\191\SOH\EOT\US\SUBz If true, indicates that the extension must be defined as repeated.\n\ + \ Otherwise the extension must be defined as optional.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\EOT\EOT\DC2\EOT\191\SOH\EOT\f\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\EOT\ENQ\DC2\EOT\191\SOH\r\DC1\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\EOT\SOH\DC2\EOT\191\SOH\DC2\SUB\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\STX\EOT\ETX\DC2\EOT\191\SOH\GS\RS\n\ + \$\n\ + \\ENQ\EOT\ETX\ETX\NUL\t\DC2\EOT\193\SOH\EOT\SI\"\NAK removed is_repeated\n\ + \\n\ + \\SO\n\ + \\ACK\EOT\ETX\ETX\NUL\t\NUL\DC2\EOT\193\SOH\r\SO\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\t\NUL\SOH\DC2\EOT\193\SOH\r\SO\n\ + \\SI\n\ + \\a\EOT\ETX\ETX\NUL\t\NUL\STX\DC2\EOT\193\SOH\r\SO\n\ + \\177\SOH\n\ + \\EOT\EOT\ETX\STX\SOH\DC2\EOT\199\SOH\STXF\SUB\162\SOH For external users: DO NOT USE. We are in the process of open sourcing\n\ + \ extension declaration and executing internal cleanups before it can be\n\ + \ used externally.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\SOH\EOT\DC2\EOT\199\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\SOH\ACK\DC2\EOT\199\SOH\v\SYN\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\SOH\SOH\DC2\EOT\199\SOH\ETB\"\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\SOH\ETX\DC2\EOT\199\SOH%&\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\SOH\b\DC2\EOT\199\SOH'E\n\ + \\SO\n\ + \\ACK\EOT\ETX\STX\SOH\b\DC1\DC2\EOT\199\SOH(D\n\ + \=\n\ + \\EOT\EOT\ETX\STX\STX\DC2\EOT\202\SOH\STX$\SUB/ Any features defined in the specific edition.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\STX\EOT\DC2\EOT\202\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\STX\ACK\DC2\EOT\202\SOH\v\NAK\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\STX\SOH\DC2\EOT\202\SOH\SYN\RS\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\STX\ETX\DC2\EOT\202\SOH!#\n\ + \@\n\ + \\EOT\EOT\ETX\EOT\NUL\DC2\ACK\205\SOH\STX\209\SOH\ETX\SUB0 The verification state of the extension range.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\EOT\NUL\SOH\DC2\EOT\205\SOH\a\CAN\n\ + \C\n\ + \\ACK\EOT\ETX\EOT\NUL\STX\NUL\DC2\EOT\207\SOH\EOT\DC4\SUB3 All the extensions of the range must be declared.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ETX\EOT\NUL\STX\NUL\SOH\DC2\EOT\207\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\ETX\EOT\NUL\STX\NUL\STX\DC2\EOT\207\SOH\DC2\DC3\n\ + \\SO\n\ + \\ACK\EOT\ETX\EOT\NUL\STX\SOH\DC2\EOT\208\SOH\EOT\DC3\n\ + \\SI\n\ + \\a\EOT\ETX\EOT\NUL\STX\SOH\SOH\DC2\EOT\208\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\ETX\EOT\NUL\STX\SOH\STX\DC2\EOT\208\SOH\DC1\DC2\n\ + \\142\SOH\n\ + \\EOT\EOT\ETX\STX\ETX\DC2\ACK\214\SOH\STX\215\SOH;\SUB~ The verification state of the range.\n\ + \ TODO: flip the default to DECLARATION once all empty ranges\n\ + \ are marked as UNVERIFIED.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\EOT\DC2\EOT\214\SOH\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\ACK\DC2\EOT\214\SOH\v\FS\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\SOH\DC2\EOT\214\SOH\GS)\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\ETX\DC2\EOT\214\SOH,-\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\b\DC2\EOT\215\SOH\ACK:\n\ + \\r\n\ + \\ENQ\EOT\ETX\STX\ETX\a\DC2\EOT\215\SOH\DC1\ESC\n\ + \\SO\n\ + \\ACK\EOT\ETX\STX\ETX\b\DC1\DC2\EOT\215\SOH\GS9\n\ + \Z\n\ + \\ETX\EOT\ETX\ENQ\DC2\EOT\218\SOH\STX\EM\SUBM Clients can define custom options in extensions of this message. See above.\n\ + \\n\ + \\f\n\ + \\EOT\EOT\ETX\ENQ\NUL\DC2\EOT\218\SOH\r\CAN\n\ + \\r\n\ + \\ENQ\EOT\ETX\ENQ\NUL\SOH\DC2\EOT\218\SOH\r\DC1\n\ + \\r\n\ + \\ENQ\EOT\ETX\ENQ\NUL\STX\DC2\EOT\218\SOH\NAK\CAN\n\ + \3\n\ + \\STX\EOT\EOT\DC2\ACK\222\SOH\NUL\198\STX\SOH\SUB% Describes a field within a message.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\EOT\SOH\DC2\EOT\222\SOH\b\FS\n\ + \\SO\n\ + \\EOT\EOT\EOT\EOT\NUL\DC2\ACK\223\SOH\STX\255\SOH\ETX\n\ + \\r\n\ + \\ENQ\EOT\EOT\EOT\NUL\SOH\DC2\EOT\223\SOH\a\v\n\ + \S\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\NUL\DC2\EOT\226\SOH\EOT\DC4\SUBC 0 is reserved for errors.\n\ + \ Order is weird for historical reasons.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\NUL\SOH\DC2\EOT\226\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\NUL\STX\DC2\EOT\226\SOH\DC2\DC3\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\SOH\DC2\EOT\227\SOH\EOT\DC3\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SOH\SOH\DC2\EOT\227\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SOH\STX\DC2\EOT\227\SOH\DC1\DC2\n\ + \w\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\STX\DC2\EOT\230\SOH\EOT\DC3\SUBg Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if\n\ + \ negative values are likely.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\STX\SOH\DC2\EOT\230\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\STX\STX\DC2\EOT\230\SOH\DC1\DC2\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\ETX\DC2\EOT\231\SOH\EOT\DC4\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ETX\SOH\DC2\EOT\231\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ETX\STX\DC2\EOT\231\SOH\DC2\DC3\n\ + \w\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\EOT\DC2\EOT\234\SOH\EOT\DC3\SUBg Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if\n\ + \ negative values are likely.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\EOT\SOH\DC2\EOT\234\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\EOT\STX\DC2\EOT\234\SOH\DC1\DC2\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\ENQ\DC2\EOT\235\SOH\EOT\NAK\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ENQ\SOH\DC2\EOT\235\SOH\EOT\DLE\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ENQ\STX\DC2\EOT\235\SOH\DC3\DC4\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\ACK\DC2\EOT\236\SOH\EOT\NAK\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ACK\SOH\DC2\EOT\236\SOH\EOT\DLE\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\ACK\STX\DC2\EOT\236\SOH\DC3\DC4\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\a\DC2\EOT\237\SOH\EOT\DC2\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\a\SOH\DC2\EOT\237\SOH\EOT\r\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\a\STX\DC2\EOT\237\SOH\DLE\DC1\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\b\DC2\EOT\238\SOH\EOT\DC4\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\b\SOH\DC2\EOT\238\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\b\STX\DC2\EOT\238\SOH\DC2\DC3\n\ + \\198\STX\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\t\DC2\EOT\244\SOH\EOT\DC4\SUB\181\STX Tag-delimited aggregate.\n\ + \ Group type is deprecated and not supported after google.protobuf. However, Proto3\n\ + \ implementations should still be able to parse the group wire format and\n\ + \ treat group fields as unknown fields. In Editions, the group wire format\n\ + \ can be enabled via the `message_encoding` feature.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\t\SOH\DC2\EOT\244\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\t\STX\DC2\EOT\244\SOH\DC1\DC3\n\ + \-\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\n\ + \\DC2\EOT\245\SOH\EOT\SYN\"\GS Length-delimited aggregate.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\n\ + \\SOH\DC2\EOT\245\SOH\EOT\DLE\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\n\ + \\STX\DC2\EOT\245\SOH\DC3\NAK\n\ + \#\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\v\DC2\EOT\248\SOH\EOT\DC4\SUB\DC3 New in version 2.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\v\SOH\DC2\EOT\248\SOH\EOT\SO\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\v\STX\DC2\EOT\248\SOH\DC1\DC3\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\f\DC2\EOT\249\SOH\EOT\NAK\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\f\SOH\DC2\EOT\249\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\f\STX\DC2\EOT\249\SOH\DC2\DC4\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\r\DC2\EOT\250\SOH\EOT\DC3\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\r\SOH\DC2\EOT\250\SOH\EOT\r\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\r\STX\DC2\EOT\250\SOH\DLE\DC2\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\SO\DC2\EOT\251\SOH\EOT\ETB\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SO\SOH\DC2\EOT\251\SOH\EOT\DC1\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SO\STX\DC2\EOT\251\SOH\DC4\SYN\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\SI\DC2\EOT\252\SOH\EOT\ETB\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SI\SOH\DC2\EOT\252\SOH\EOT\DC1\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\SI\STX\DC2\EOT\252\SOH\DC4\SYN\n\ + \'\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\DLE\DC2\EOT\253\SOH\EOT\NAK\"\ETB Uses ZigZag encoding.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\DLE\SOH\DC2\EOT\253\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\DLE\STX\DC2\EOT\253\SOH\DC2\DC4\n\ + \'\n\ + \\ACK\EOT\EOT\EOT\NUL\STX\DC1\DC2\EOT\254\SOH\EOT\NAK\"\ETB Uses ZigZag encoding.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\DC1\SOH\DC2\EOT\254\SOH\EOT\SI\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\NUL\STX\DC1\STX\DC2\EOT\254\SOH\DC2\DC4\n\ + \\SO\n\ + \\EOT\EOT\EOT\EOT\SOH\DC2\ACK\129\STX\STX\137\STX\ETX\n\ + \\r\n\ + \\ENQ\EOT\EOT\EOT\SOH\SOH\DC2\EOT\129\STX\a\f\n\ + \*\n\ + \\ACK\EOT\EOT\EOT\SOH\STX\NUL\DC2\EOT\131\STX\EOT\ETB\SUB\SUB 0 is reserved for errors\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\NUL\SOH\DC2\EOT\131\STX\EOT\DC2\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\NUL\STX\DC2\EOT\131\STX\NAK\SYN\n\ + \\SO\n\ + \\ACK\EOT\EOT\EOT\SOH\STX\SOH\DC2\EOT\132\STX\EOT\ETB\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\SOH\SOH\DC2\EOT\132\STX\EOT\DC2\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\SOH\STX\DC2\EOT\132\STX\NAK\SYN\n\ + \\204\SOH\n\ + \\ACK\EOT\EOT\EOT\SOH\STX\STX\DC2\EOT\136\STX\EOT\ETB\SUB\187\SOH The required label is only allowed in google.protobuf. In proto3 and Editions\n\ + \ it's explicitly prohibited. In Editions, the `field_presence` feature\n\ + \ can be used to get this behavior.\n\ + \\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\STX\SOH\DC2\EOT\136\STX\EOT\DC2\n\ + \\SI\n\ + \\a\EOT\EOT\EOT\SOH\STX\STX\STX\DC2\EOT\136\STX\NAK\SYN\n\ + \\f\n\ + \\EOT\EOT\EOT\STX\NUL\DC2\EOT\139\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\NUL\EOT\DC2\EOT\139\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\NUL\ENQ\DC2\EOT\139\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\NUL\SOH\DC2\EOT\139\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\NUL\ETX\DC2\EOT\139\STX\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\EOT\STX\SOH\DC2\EOT\140\STX\STX\FS\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\SOH\EOT\DC2\EOT\140\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\SOH\ENQ\DC2\EOT\140\STX\v\DLE\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\SOH\SOH\DC2\EOT\140\STX\DC1\ETB\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\SOH\ETX\DC2\EOT\140\STX\SUB\ESC\n\ + \\f\n\ + \\EOT\EOT\EOT\STX\STX\DC2\EOT\141\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\STX\EOT\DC2\EOT\141\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\STX\ACK\DC2\EOT\141\STX\v\DLE\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\STX\SOH\DC2\EOT\141\STX\DC1\SYN\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\STX\ETX\DC2\EOT\141\STX\EM\SUB\n\ + \\156\SOH\n\ + \\EOT\EOT\EOT\STX\ETX\DC2\EOT\145\STX\STX\EM\SUB\141\SOH If type_name is set, this need not be set. If both this and type_name\n\ + \ are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ETX\EOT\DC2\EOT\145\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ETX\ACK\DC2\EOT\145\STX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ETX\SOH\DC2\EOT\145\STX\DLE\DC4\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ETX\ETX\DC2\EOT\145\STX\ETB\CAN\n\ + \\183\STX\n\ + \\EOT\EOT\EOT\STX\EOT\DC2\EOT\152\STX\STX \SUB\168\STX For message and enum types, this is the name of the type. If the name\n\ + \ starts with a '.', it is fully-qualified. Otherwise, C++-like scoping\n\ + \ rules are used to find the type (i.e. first the nested types within this\n\ + \ message are searched, then within the parent, on up to the root\n\ + \ namespace).\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\EOT\EOT\DC2\EOT\152\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\EOT\ENQ\DC2\EOT\152\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\EOT\SOH\DC2\EOT\152\STX\DC2\ESC\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\EOT\ETX\DC2\EOT\152\STX\RS\US\n\ + \~\n\ + \\EOT\EOT\EOT\STX\ENQ\DC2\EOT\156\STX\STX\US\SUBp For extensions, this is the name of the type being extended. It is\n\ + \ resolved in the same manner as type_name.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ENQ\EOT\DC2\EOT\156\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ENQ\ENQ\DC2\EOT\156\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ENQ\SOH\DC2\EOT\156\STX\DC2\SUB\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ENQ\ETX\DC2\EOT\156\STX\GS\RS\n\ + \\145\STX\n\ + \\EOT\EOT\EOT\STX\ACK\DC2\EOT\162\STX\STX$\SUB\130\STX For numeric types, contains the original text representation of the value.\n\ + \ For booleans, \"true\" or \"false\".\n\ + \ For strings, contains the default text contents (not escaped in any way).\n\ + \ For bytes, contains the C escaped value. All bytes >= 128 are escaped.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ACK\EOT\DC2\EOT\162\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ACK\ENQ\DC2\EOT\162\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ACK\SOH\DC2\EOT\162\STX\DC2\US\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\ACK\ETX\DC2\EOT\162\STX\"#\n\ + \\132\SOH\n\ + \\EOT\EOT\EOT\STX\a\DC2\EOT\166\STX\STX!\SUBv If set, gives the index of a oneof in the containing type's oneof_decl\n\ + \ list. This field is a member of that oneof.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\a\EOT\DC2\EOT\166\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\a\ENQ\DC2\EOT\166\STX\v\DLE\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\a\SOH\DC2\EOT\166\STX\DC1\FS\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\a\ETX\DC2\EOT\166\STX\US \n\ + \\250\SOH\n\ + \\EOT\EOT\EOT\STX\b\DC2\EOT\172\STX\STX!\SUB\235\SOH JSON name of this field. The value is set by protocol compiler. If the\n\ + \ user has set a \"json_name\" option on this field, that option's value\n\ + \ will be used. Otherwise, it's deduced from the field's name by converting\n\ + \ it to camelCase.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\b\EOT\DC2\EOT\172\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\b\ENQ\DC2\EOT\172\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\b\SOH\DC2\EOT\172\STX\DC2\ESC\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\b\ETX\DC2\EOT\172\STX\RS \n\ + \\f\n\ + \\EOT\EOT\EOT\STX\t\DC2\EOT\174\STX\STX$\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\t\EOT\DC2\EOT\174\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\t\ACK\DC2\EOT\174\STX\v\ETB\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\t\SOH\DC2\EOT\174\STX\CAN\US\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\t\ETX\DC2\EOT\174\STX\"#\n\ + \\176\t\n\ + \\EOT\EOT\EOT\STX\n\ + \\DC2\EOT\197\STX\STX%\SUB\161\t If true, this is a proto3 \"optional\". When a proto3 field is optional, it\n\ + \ tracks presence regardless of field type.\n\ + \\n\ + \ When proto3_optional is true, this field must belong to a oneof to signal\n\ + \ to old proto3 clients that presence is tracked for this field. This oneof\n\ + \ is known as a \"synthetic\" oneof, and this field must be its sole member\n\ + \ (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs\n\ + \ exist in the descriptor only, and do not generate any API. Synthetic oneofs\n\ + \ must be ordered after all \"real\" oneofs.\n\ + \\n\ + \ For message fields, proto3_optional doesn't create any semantic change,\n\ + \ since non-repeated message fields always track presence. However it still\n\ + \ indicates the semantic detail of whether the user wrote \"optional\" or not.\n\ + \ This can be useful for round-tripping the .proto file. For consistency we\n\ + \ give message fields a synthetic oneof also, even though it is not required\n\ + \ to track presence. This is especially important because the parser can't\n\ + \ tell if a field is a message or an enum, so it must always create a\n\ + \ synthetic oneof.\n\ + \\n\ + \ Proto2 optional fields do not set this flag, because they already indicate\n\ + \ optional with `LABEL_OPTIONAL`.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\n\ + \\EOT\DC2\EOT\197\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\n\ + \\ENQ\DC2\EOT\197\STX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\n\ + \\SOH\DC2\EOT\197\STX\DLE\US\n\ + \\r\n\ + \\ENQ\EOT\EOT\STX\n\ + \\ETX\DC2\EOT\197\STX\"$\n\ + \\"\n\ + \\STX\EOT\ENQ\DC2\ACK\201\STX\NUL\204\STX\SOH\SUB\DC4 Describes a oneof.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\ENQ\SOH\DC2\EOT\201\STX\b\FS\n\ + \\f\n\ + \\EOT\EOT\ENQ\STX\NUL\DC2\EOT\202\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\NUL\EOT\DC2\EOT\202\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\NUL\ENQ\DC2\EOT\202\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\NUL\SOH\DC2\EOT\202\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\NUL\ETX\DC2\EOT\202\STX\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\ENQ\STX\SOH\DC2\EOT\203\STX\STX$\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\SOH\EOT\DC2\EOT\203\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\SOH\ACK\DC2\EOT\203\STX\v\ETB\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\SOH\SOH\DC2\EOT\203\STX\CAN\US\n\ + \\r\n\ + \\ENQ\EOT\ENQ\STX\SOH\ETX\DC2\EOT\203\STX\"#\n\ + \'\n\ + \\STX\EOT\ACK\DC2\ACK\207\STX\NUL\233\STX\SOH\SUB\EM Describes an enum type.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\ACK\SOH\DC2\EOT\207\STX\b\ESC\n\ + \\f\n\ + \\EOT\EOT\ACK\STX\NUL\DC2\EOT\208\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\NUL\EOT\DC2\EOT\208\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\NUL\ENQ\DC2\EOT\208\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\NUL\SOH\DC2\EOT\208\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\NUL\ETX\DC2\EOT\208\STX\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\ACK\STX\SOH\DC2\EOT\210\STX\STX.\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\SOH\EOT\DC2\EOT\210\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\SOH\ACK\DC2\EOT\210\STX\v#\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\SOH\SOH\DC2\EOT\210\STX$)\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\SOH\ETX\DC2\EOT\210\STX,-\n\ + \\f\n\ + \\EOT\EOT\ACK\STX\STX\DC2\EOT\212\STX\STX#\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\STX\EOT\DC2\EOT\212\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\STX\ACK\DC2\EOT\212\STX\v\SYN\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\STX\SOH\DC2\EOT\212\STX\ETB\RS\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\STX\ETX\DC2\EOT\212\STX!\"\n\ + \\175\STX\n\ + \\EOT\EOT\ACK\ETX\NUL\DC2\ACK\220\STX\STX\223\STX\ETX\SUB\158\STX Range of reserved numeric values. Reserved values may not be used by\n\ + \ entries in the same enum. Reserved ranges may not overlap.\n\ + \\n\ + \ Note that this is distinct from DescriptorProto.ReservedRange in that it\n\ + \ is inclusive such that it can appropriately represent the entire int32\n\ + \ domain.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\ETX\NUL\SOH\DC2\EOT\220\STX\n\ + \\ESC\n\ + \\FS\n\ + \\ACK\EOT\ACK\ETX\NUL\STX\NUL\DC2\EOT\221\STX\EOT\GS\"\f Inclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\NUL\EOT\DC2\EOT\221\STX\EOT\f\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\NUL\ENQ\DC2\EOT\221\STX\r\DC2\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\NUL\SOH\DC2\EOT\221\STX\DC3\CAN\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\NUL\ETX\DC2\EOT\221\STX\ESC\FS\n\ + \\FS\n\ + \\ACK\EOT\ACK\ETX\NUL\STX\SOH\DC2\EOT\222\STX\EOT\ESC\"\f Inclusive.\n\ + \\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\SOH\EOT\DC2\EOT\222\STX\EOT\f\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\SOH\ENQ\DC2\EOT\222\STX\r\DC2\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\SOH\SOH\DC2\EOT\222\STX\DC3\SYN\n\ + \\SI\n\ + \\a\EOT\ACK\ETX\NUL\STX\SOH\ETX\DC2\EOT\222\STX\EM\SUB\n\ + \\170\SOH\n\ + \\EOT\EOT\ACK\STX\ETX\DC2\EOT\228\STX\STX0\SUB\155\SOH Range of reserved numeric values. Reserved numeric values may not be used\n\ + \ by enum values in the same enum declaration. Reserved ranges may not\n\ + \ overlap.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\ETX\EOT\DC2\EOT\228\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\ETX\ACK\DC2\EOT\228\STX\v\FS\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\ETX\SOH\DC2\EOT\228\STX\GS+\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\ETX\ETX\DC2\EOT\228\STX./\n\ + \l\n\ + \\EOT\EOT\ACK\STX\EOT\DC2\EOT\232\STX\STX$\SUB^ Reserved enum value names, which may not be reused. A given name may only\n\ + \ be reserved once.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\EOT\EOT\DC2\EOT\232\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\EOT\ENQ\DC2\EOT\232\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\EOT\SOH\DC2\EOT\232\STX\DC2\US\n\ + \\r\n\ + \\ENQ\EOT\ACK\STX\EOT\ETX\DC2\EOT\232\STX\"#\n\ + \1\n\ + \\STX\EOT\a\DC2\ACK\236\STX\NUL\241\STX\SOH\SUB# Describes a value within an enum.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\a\SOH\DC2\EOT\236\STX\b \n\ + \\f\n\ + \\EOT\EOT\a\STX\NUL\DC2\EOT\237\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\a\STX\NUL\EOT\DC2\EOT\237\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\a\STX\NUL\ENQ\DC2\EOT\237\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\a\STX\NUL\SOH\DC2\EOT\237\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\a\STX\NUL\ETX\DC2\EOT\237\STX\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\a\STX\SOH\DC2\EOT\238\STX\STX\FS\n\ + \\r\n\ + \\ENQ\EOT\a\STX\SOH\EOT\DC2\EOT\238\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\a\STX\SOH\ENQ\DC2\EOT\238\STX\v\DLE\n\ + \\r\n\ + \\ENQ\EOT\a\STX\SOH\SOH\DC2\EOT\238\STX\DC1\ETB\n\ + \\r\n\ + \\ENQ\EOT\a\STX\SOH\ETX\DC2\EOT\238\STX\SUB\ESC\n\ + \\f\n\ + \\EOT\EOT\a\STX\STX\DC2\EOT\240\STX\STX(\n\ + \\r\n\ + \\ENQ\EOT\a\STX\STX\EOT\DC2\EOT\240\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\a\STX\STX\ACK\DC2\EOT\240\STX\v\ESC\n\ + \\r\n\ + \\ENQ\EOT\a\STX\STX\SOH\DC2\EOT\240\STX\FS#\n\ + \\r\n\ + \\ENQ\EOT\a\STX\STX\ETX\DC2\EOT\240\STX&'\n\ + \$\n\ + \\STX\EOT\b\DC2\ACK\244\STX\NUL\249\STX\SOH\SUB\SYN Describes a service.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\b\SOH\DC2\EOT\244\STX\b\RS\n\ + \\f\n\ + \\EOT\EOT\b\STX\NUL\DC2\EOT\245\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\b\STX\NUL\EOT\DC2\EOT\245\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\b\STX\NUL\ENQ\DC2\EOT\245\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\b\STX\NUL\SOH\DC2\EOT\245\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\b\STX\NUL\ETX\DC2\EOT\245\STX\EM\SUB\n\ + \\f\n\ + \\EOT\EOT\b\STX\SOH\DC2\EOT\246\STX\STX,\n\ + \\r\n\ + \\ENQ\EOT\b\STX\SOH\EOT\DC2\EOT\246\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\b\STX\SOH\ACK\DC2\EOT\246\STX\v \n\ + \\r\n\ + \\ENQ\EOT\b\STX\SOH\SOH\DC2\EOT\246\STX!'\n\ + \\r\n\ + \\ENQ\EOT\b\STX\SOH\ETX\DC2\EOT\246\STX*+\n\ + \\f\n\ + \\EOT\EOT\b\STX\STX\DC2\EOT\248\STX\STX&\n\ + \\r\n\ + \\ENQ\EOT\b\STX\STX\EOT\DC2\EOT\248\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\b\STX\STX\ACK\DC2\EOT\248\STX\v\EM\n\ + \\r\n\ + \\ENQ\EOT\b\STX\STX\SOH\DC2\EOT\248\STX\SUB!\n\ + \\r\n\ + \\ENQ\EOT\b\STX\STX\ETX\DC2\EOT\248\STX$%\n\ + \0\n\ + \\STX\EOT\t\DC2\ACK\252\STX\NUL\138\ETX\SOH\SUB\" Describes a method of a service.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\t\SOH\DC2\EOT\252\STX\b\GS\n\ + \\f\n\ + \\EOT\EOT\t\STX\NUL\DC2\EOT\253\STX\STX\ESC\n\ + \\r\n\ + \\ENQ\EOT\t\STX\NUL\EOT\DC2\EOT\253\STX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\NUL\ENQ\DC2\EOT\253\STX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\t\STX\NUL\SOH\DC2\EOT\253\STX\DC2\SYN\n\ + \\r\n\ + \\ENQ\EOT\t\STX\NUL\ETX\DC2\EOT\253\STX\EM\SUB\n\ + \\151\SOH\n\ + \\EOT\EOT\t\STX\SOH\DC2\EOT\129\ETX\STX!\SUB\136\SOH Input and output type names. These are resolved in the same way as\n\ + \ FieldDescriptorProto.type_name, but must refer to a message type.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\SOH\EOT\DC2\EOT\129\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\SOH\ENQ\DC2\EOT\129\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\t\STX\SOH\SOH\DC2\EOT\129\ETX\DC2\FS\n\ + \\r\n\ + \\ENQ\EOT\t\STX\SOH\ETX\DC2\EOT\129\ETX\US \n\ + \\f\n\ + \\EOT\EOT\t\STX\STX\DC2\EOT\130\ETX\STX\"\n\ + \\r\n\ + \\ENQ\EOT\t\STX\STX\EOT\DC2\EOT\130\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\STX\ENQ\DC2\EOT\130\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\t\STX\STX\SOH\DC2\EOT\130\ETX\DC2\GS\n\ + \\r\n\ + \\ENQ\EOT\t\STX\STX\ETX\DC2\EOT\130\ETX !\n\ + \\f\n\ + \\EOT\EOT\t\STX\ETX\DC2\EOT\132\ETX\STX%\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ETX\EOT\DC2\EOT\132\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ETX\ACK\DC2\EOT\132\ETX\v\CAN\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ETX\SOH\DC2\EOT\132\ETX\EM \n\ + \\r\n\ + \\ENQ\EOT\t\STX\ETX\ETX\DC2\EOT\132\ETX#$\n\ + \E\n\ + \\EOT\EOT\t\STX\EOT\DC2\EOT\135\ETX\STX7\SUB7 Identifies if client streams multiple client messages\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\EOT\DC2\EOT\135\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\ENQ\DC2\EOT\135\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\SOH\DC2\EOT\135\ETX\DLE \n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\ETX\DC2\EOT\135\ETX#$\n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\b\DC2\EOT\135\ETX%6\n\ + \\r\n\ + \\ENQ\EOT\t\STX\EOT\a\DC2\EOT\135\ETX05\n\ + \E\n\ + \\EOT\EOT\t\STX\ENQ\DC2\EOT\137\ETX\STX7\SUB7 Identifies if server streams multiple server messages\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\EOT\DC2\EOT\137\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\ENQ\DC2\EOT\137\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\SOH\DC2\EOT\137\ETX\DLE \n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\ETX\DC2\EOT\137\ETX#$\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\b\DC2\EOT\137\ETX%6\n\ + \\r\n\ + \\ENQ\EOT\t\STX\ENQ\a\DC2\EOT\137\ETX05\n\ + \\175\SO\n\ + \\STX\EOT\n\ + \\DC2\ACK\172\ETX\NUL\168\EOT\SOH2N ===================================================================\n\ + \ Options\n\ + \2\208\r Each of the definitions above may have \"options\" attached. These are\n\ + \ just annotations which may cause code to be generated slightly differently\n\ + \ or may contain hints for code that manipulates protocol messages.\n\ + \\n\ + \ Clients may define custom options as extensions of the *Options messages.\n\ + \ These extensions may not yet be known at parsing time, so the parser cannot\n\ + \ store the values in them. Instead it stores them in a field in the *Options\n\ + \ message called uninterpreted_option. This field must have the same name\n\ + \ across all *Options messages. We then use this field to populate the\n\ + \ extensions when we build a descriptor, at which point all protos have been\n\ + \ parsed and so all extensions are known.\n\ + \\n\ + \ Extension numbers for custom options may be chosen as follows:\n\ + \ * For options which will only be used within a single application or\n\ + \ organization, or for experimental options, use field numbers 50000\n\ + \ through 99999. It is up to you to ensure that you do not use the\n\ + \ same number for multiple options.\n\ + \ * For options which will be published and used publicly by multiple\n\ + \ independent entities, e-mail protobuf-global-extension-registry@google.com\n\ + \ to reserve extension numbers. Simply provide your project name (e.g.\n\ + \ Objective-C plugin) and your project website (if available) -- there's no\n\ + \ need to explain how you intend to use them. Usually you only need one\n\ + \ extension number. You can declare multiple options with only one extension\n\ + \ number by putting them in a sub-message. See the Custom Options section of\n\ + \ the docs for examples:\n\ + \ https://developers.google.com/protocol-buffers/docs/proto#options\n\ + \ If this turns out to be popular, a web service will be set up\n\ + \ to automatically assign option numbers.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\n\ + \\SOH\DC2\EOT\172\ETX\b\DC3\n\ + \\244\SOH\n\ + \\EOT\EOT\n\ + \\STX\NUL\DC2\EOT\178\ETX\STX#\SUB\229\SOH Sets the Java package where classes generated from this .proto will be\n\ + \ placed. By default, the proto package is used, but this is often\n\ + \ inappropriate because proto packages do not normally start with backwards\n\ + \ domain names.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\NUL\EOT\DC2\EOT\178\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\NUL\ENQ\DC2\EOT\178\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\NUL\SOH\DC2\EOT\178\ETX\DC2\RS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\NUL\ETX\DC2\EOT\178\ETX!\"\n\ + \\241\STX\n\ + \\EOT\EOT\n\ + \\STX\SOH\DC2\EOT\185\ETX\STX+\SUB\226\STX Controls the name of the wrapper Java class generated for the .proto file.\n\ + \ That class will always contain the .proto file's getDescriptor() method as\n\ + \ well as any top-level extensions defined in the .proto file.\n\ + \ If java_multiple_files is disabled, then all the other classes from the\n\ + \ .proto file will be nested inside the single wrapper outer class.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SOH\EOT\DC2\EOT\185\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SOH\ENQ\DC2\EOT\185\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SOH\SOH\DC2\EOT\185\ETX\DC2&\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SOH\ETX\DC2\EOT\185\ETX)*\n\ + \\166\ETX\n\ + \\EOT\EOT\n\ + \\STX\STX\DC2\EOT\193\ETX\STX;\SUB\151\ETX If enabled, then the Java code generator will generate a separate .java\n\ + \ file for each top-level message, enum, and service defined in the .proto\n\ + \ file. Thus, these types will *not* be nested inside the wrapper class\n\ + \ named by java_outer_classname. However, the wrapper class will still be\n\ + \ generated to contain the file's getDescriptor() method as well as any\n\ + \ top-level extensions defined in the file.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\EOT\DC2\EOT\193\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\ENQ\DC2\EOT\193\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\SOH\DC2\EOT\193\ETX\DLE#\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\ETX\DC2\EOT\193\ETX&(\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\b\DC2\EOT\193\ETX):\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\STX\a\DC2\EOT\193\ETX49\n\ + \)\n\ + \\EOT\EOT\n\ + \\STX\ETX\DC2\EOT\196\ETX\STXE\SUB\ESC This option does nothing.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ETX\EOT\DC2\EOT\196\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ETX\ENQ\DC2\EOT\196\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ETX\SOH\DC2\EOT\196\ETX\DLE-\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ETX\ETX\DC2\EOT\196\ETX02\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ETX\b\DC2\EOT\196\ETX3D\n\ + \\SO\n\ + \\ACK\EOT\n\ + \\STX\ETX\b\ETX\DC2\EOT\196\ETX4C\n\ + \\207\ETX\n\ + \\EOT\EOT\n\ + \\STX\EOT\DC2\EOT\208\ETX\STX>\SUB\192\ETX A proto2 file can set this to true to opt in to UTF-8 checking for Java,\n\ + \ which will throw an exception if invalid UTF-8 is parsed from the wire or\n\ + \ assigned to a string field.\n\ + \\n\ + \ TODO: clarify exactly what kinds of field types this option\n\ + \ applies to, and update these docs accordingly.\n\ + \\n\ + \ Proto3 files already perform these checks. Setting the option explicitly to\n\ + \ false has no effect: it cannot be used to opt proto3 files out of UTF-8\n\ + \ checks.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\EOT\DC2\EOT\208\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\ENQ\DC2\EOT\208\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\SOH\DC2\EOT\208\ETX\DLE&\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\ETX\DC2\EOT\208\ETX)+\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\b\DC2\EOT\208\ETX,=\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\EOT\a\DC2\EOT\208\ETX7<\n\ + \L\n\ + \\EOT\EOT\n\ + \\EOT\NUL\DC2\ACK\211\ETX\STX\216\ETX\ETX\SUB< Generated classes can be optimized for speed or code size.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\EOT\NUL\SOH\DC2\EOT\211\ETX\a\DC3\n\ + \D\n\ + \\ACK\EOT\n\ + \\EOT\NUL\STX\NUL\DC2\EOT\212\ETX\EOT\SO\"4 Generate complete code for parsing, serialization,\n\ + \\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\NUL\SOH\DC2\EOT\212\ETX\EOT\t\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\NUL\STX\DC2\EOT\212\ETX\f\r\n\ + \G\n\ + \\ACK\EOT\n\ + \\EOT\NUL\STX\SOH\DC2\EOT\214\ETX\EOT\DC2\SUB\ACK etc.\n\ + \\"/ Use ReflectionOps to implement these methods.\n\ + \\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\SOH\SOH\DC2\EOT\214\ETX\EOT\r\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\SOH\STX\DC2\EOT\214\ETX\DLE\DC1\n\ + \G\n\ + \\ACK\EOT\n\ + \\EOT\NUL\STX\STX\DC2\EOT\215\ETX\EOT\NAK\"7 Generate code using MessageLite and the lite runtime.\n\ + \\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\STX\SOH\DC2\EOT\215\ETX\EOT\DLE\n\ + \\SI\n\ + \\a\EOT\n\ + \\EOT\NUL\STX\STX\STX\DC2\EOT\215\ETX\DC3\DC4\n\ + \\f\n\ + \\EOT\EOT\n\ + \\STX\ENQ\DC2\EOT\217\ETX\STX;\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\EOT\DC2\EOT\217\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\ACK\DC2\EOT\217\ETX\v\ETB\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\SOH\DC2\EOT\217\ETX\CAN$\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\ETX\DC2\EOT\217\ETX'(\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\b\DC2\EOT\217\ETX):\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ENQ\a\DC2\EOT\217\ETX49\n\ + \\226\STX\n\ + \\EOT\EOT\n\ + \\STX\ACK\DC2\EOT\224\ETX\STX\"\SUB\211\STX Sets the Go package where structs generated from this .proto will be\n\ + \ placed. If omitted, the Go package will be derived from the following:\n\ + \ - The basename of the package import path, if provided.\n\ + \ - Otherwise, the package statement in the .proto file, if present.\n\ + \ - Otherwise, the basename of the .proto file, without extension.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ACK\EOT\DC2\EOT\224\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ACK\ENQ\DC2\EOT\224\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ACK\SOH\DC2\EOT\224\ETX\DC2\FS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\ACK\ETX\DC2\EOT\224\ETX\US!\n\ + \\212\EOT\n\ + \\EOT\EOT\n\ + \\STX\a\DC2\EOT\236\ETX\STX;\SUB\197\EOT Should generic services be generated in each language? \"Generic\" services\n\ + \ are not specific to any particular RPC system. They are generated by the\n\ + \ main code generators in each language (without additional plugins).\n\ + \ Generic services were the only kind of service generation supported by\n\ + \ early versions of google.protobuf.\n\ + \\n\ + \ Generic services are now considered deprecated in favor of using plugins\n\ + \ that generate code specific to your particular RPC system. Therefore,\n\ + \ these default to false. Old code which depends on generic services should\n\ + \ explicitly set them to true.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\EOT\DC2\EOT\236\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\ENQ\DC2\EOT\236\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\SOH\DC2\EOT\236\ETX\DLE#\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\ETX\DC2\EOT\236\ETX&(\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\b\DC2\EOT\236\ETX):\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\a\a\DC2\EOT\236\ETX49\n\ + \\f\n\ + \\EOT\EOT\n\ + \\STX\b\DC2\EOT\237\ETX\STX=\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\EOT\DC2\EOT\237\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\ENQ\DC2\EOT\237\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\SOH\DC2\EOT\237\ETX\DLE%\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\ETX\DC2\EOT\237\ETX(*\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\b\DC2\EOT\237\ETX+<\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\b\a\DC2\EOT\237\ETX6;\n\ + \\f\n\ + \\EOT\EOT\n\ + \\STX\t\DC2\EOT\238\ETX\STX;\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\EOT\DC2\EOT\238\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\ENQ\DC2\EOT\238\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\SOH\DC2\EOT\238\ETX\DLE#\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\ETX\DC2\EOT\238\ETX&(\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\b\DC2\EOT\238\ETX):\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\t\a\DC2\EOT\238\ETX49\n\ + \+\n\ + \\ETX\EOT\n\ + \\t\DC2\EOT\239\ETX\STX\SO\"\RS removed php_generic_services\n\ + \\n\ + \\f\n\ + \\EOT\EOT\n\ + \\t\NUL\DC2\EOT\239\ETX\v\r\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\t\NUL\SOH\DC2\EOT\239\ETX\v\r\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\t\NUL\STX\DC2\EOT\239\ETX\v\r\n\ + \\v\n\ + \\ETX\EOT\n\ + \\n\ + \\DC2\EOT\240\ETX\STX\"\n\ + \\f\n\ + \\EOT\EOT\n\ + \\n\ + \\NUL\DC2\EOT\240\ETX\v!\n\ + \\243\SOH\n\ + \\EOT\EOT\n\ + \\STX\n\ + \\DC2\EOT\246\ETX\STX2\SUB\228\SOH Is this file deprecated?\n\ + \ Depending on the target platform, this can emit Deprecated annotations\n\ + \ for everything in the file, or it will be completely ignored; in the very\n\ + \ least, this is a formalization for deprecating files.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\EOT\DC2\EOT\246\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\ENQ\DC2\EOT\246\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\SOH\DC2\EOT\246\ETX\DLE\SUB\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\ETX\DC2\EOT\246\ETX\GS\US\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\b\DC2\EOT\246\ETX 1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\n\ + \\a\DC2\EOT\246\ETX+0\n\ + \\DEL\n\ + \\EOT\EOT\n\ + \\STX\v\DC2\EOT\250\ETX\STX7\SUBq Enables the use of arenas for the proto messages in this file. This applies\n\ + \ only to generated classes for C++.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\EOT\DC2\EOT\250\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\ENQ\DC2\EOT\250\ETX\v\SI\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\SOH\DC2\EOT\250\ETX\DLE \n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\ETX\DC2\EOT\250\ETX#%\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\b\DC2\EOT\250\ETX&6\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\v\a\DC2\EOT\250\ETX15\n\ + \\146\SOH\n\ + \\EOT\EOT\n\ + \\STX\f\DC2\EOT\254\ETX\STX)\SUB\131\SOH Sets the objective c class prefix which is prepended to all objective c\n\ + \ generated classes from this .proto. There is no default.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\f\EOT\DC2\EOT\254\ETX\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\f\ENQ\DC2\EOT\254\ETX\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\f\SOH\DC2\EOT\254\ETX\DC2#\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\f\ETX\DC2\EOT\254\ETX&(\n\ + \I\n\ + \\EOT\EOT\n\ + \\STX\r\DC2\EOT\129\EOT\STX(\SUB; Namespace for generated classes; defaults to the package.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\r\EOT\DC2\EOT\129\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\r\ENQ\DC2\EOT\129\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\r\SOH\DC2\EOT\129\EOT\DC2\"\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\r\ETX\DC2\EOT\129\EOT%'\n\ + \\145\STX\n\ + \\EOT\EOT\n\ + \\STX\SO\DC2\EOT\135\EOT\STX$\SUB\130\STX By default Swift generators will take the proto package and CamelCase it\n\ + \ replacing '.' with underscore and use that to prefix the types/symbols\n\ + \ defined. When this options is provided, they will use this value instead\n\ + \ to prefix the types/symbols defined.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SO\EOT\DC2\EOT\135\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SO\ENQ\DC2\EOT\135\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SO\SOH\DC2\EOT\135\EOT\DC2\RS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SO\ETX\DC2\EOT\135\EOT!#\n\ + \~\n\ + \\EOT\EOT\n\ + \\STX\SI\DC2\EOT\139\EOT\STX(\SUBp Sets the php class prefix which is prepended to all php generated classes\n\ + \ from this .proto. Default is empty.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SI\EOT\DC2\EOT\139\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SI\ENQ\DC2\EOT\139\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SI\SOH\DC2\EOT\139\EOT\DC2\"\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\SI\ETX\DC2\EOT\139\EOT%'\n\ + \\190\SOH\n\ + \\EOT\EOT\n\ + \\STX\DLE\DC2\EOT\144\EOT\STX%\SUB\175\SOH Use this option to change the namespace of php generated classes. Default\n\ + \ is empty. When this option is empty, the package name will be used for\n\ + \ determining the namespace.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DLE\EOT\DC2\EOT\144\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DLE\ENQ\DC2\EOT\144\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DLE\SOH\DC2\EOT\144\EOT\DC2\US\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DLE\ETX\DC2\EOT\144\EOT\"$\n\ + \\202\SOH\n\ + \\EOT\EOT\n\ + \\STX\DC1\DC2\EOT\149\EOT\STX.\SUB\187\SOH Use this option to change the namespace of php generated metadata classes.\n\ + \ Default is empty. When this option is empty, the proto file name will be\n\ + \ used for determining the namespace.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC1\EOT\DC2\EOT\149\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC1\ENQ\DC2\EOT\149\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC1\SOH\DC2\EOT\149\EOT\DC2(\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC1\ETX\DC2\EOT\149\EOT+-\n\ + \\194\SOH\n\ + \\EOT\EOT\n\ + \\STX\DC2\DC2\EOT\154\EOT\STX$\SUB\179\SOH Use this option to change the package of ruby generated classes. Default\n\ + \ is empty. When this option is not set, the package name will be used for\n\ + \ determining the ruby package.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC2\EOT\DC2\EOT\154\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC2\ENQ\DC2\EOT\154\EOT\v\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC2\SOH\DC2\EOT\154\EOT\DC2\RS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC2\ETX\DC2\EOT\154\EOT!#\n\ + \=\n\ + \\EOT\EOT\n\ + \\STX\DC3\DC2\EOT\157\EOT\STX$\SUB/ Any features defined in the specific edition.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC3\EOT\DC2\EOT\157\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC3\ACK\DC2\EOT\157\EOT\v\NAK\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC3\SOH\DC2\EOT\157\EOT\SYN\RS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC3\ETX\DC2\EOT\157\EOT!#\n\ + \|\n\ + \\EOT\EOT\n\ + \\STX\DC4\DC2\EOT\161\EOT\STX:\SUBn The parser stores options it doesn't recognize here.\n\ + \ See the documentation for the \"Options\" section above.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC4\EOT\DC2\EOT\161\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC4\ACK\DC2\EOT\161\EOT\v\RS\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC4\SOH\DC2\EOT\161\EOT\US3\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\STX\DC4\ETX\DC2\EOT\161\EOT69\n\ + \\135\SOH\n\ + \\ETX\EOT\n\ + \\ENQ\DC2\EOT\165\EOT\STX\EM\SUBz Clients can define custom options in extensions of this message.\n\ + \ See the documentation for the \"Options\" section above.\n\ + \\n\ + \\f\n\ + \\EOT\EOT\n\ + \\ENQ\NUL\DC2\EOT\165\EOT\r\CAN\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\ENQ\NUL\SOH\DC2\EOT\165\EOT\r\DC1\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\ENQ\NUL\STX\DC2\EOT\165\EOT\NAK\CAN\n\ + \\v\n\ + \\ETX\EOT\n\ + \\t\DC2\EOT\167\EOT\STX\SO\n\ + \\f\n\ + \\EOT\EOT\n\ + \\t\SOH\DC2\EOT\167\EOT\v\r\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\t\SOH\SOH\DC2\EOT\167\EOT\v\r\n\ + \\r\n\ + \\ENQ\EOT\n\ + \\t\SOH\STX\DC2\EOT\167\EOT\v\r\n\ + \\f\n\ + \\STX\EOT\v\DC2\ACK\170\EOT\NUL\250\EOT\SOH\n\ + \\v\n\ + \\ETX\EOT\v\SOH\DC2\EOT\170\EOT\b\SYN\n\ + \\216\ENQ\n\ + \\EOT\EOT\v\STX\NUL\DC2\EOT\189\EOT\STX>\SUB\201\ENQ Set true to use the old proto1 MessageSet wire format for extensions.\n\ + \ This is provided for backwards-compatibility with the MessageSet wire\n\ + \ format. You should not use this for any other reason: It's less\n\ + \ efficient, has fewer features, and is more complicated.\n\ + \\n\ + \ The message must be defined exactly as follows:\n\ + \ message Foo {\n\ + \ option message_set_wire_format = true;\n\ + \ extensions 4 to max;\n\ + \ }\n\ + \ Note that the message cannot have any defined fields; MessageSets only\n\ + \ have extensions.\n\ + \\n\ + \ All extensions of your type must be singular messages; e.g. they cannot\n\ + \ be int32s, enums, or repeated messages.\n\ + \\n\ + \ Because this is an option, the above two restrictions are not enforced by\n\ + \ the protocol compiler.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\EOT\DC2\EOT\189\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\ENQ\DC2\EOT\189\EOT\v\SI\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\SOH\DC2\EOT\189\EOT\DLE'\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\ETX\DC2\EOT\189\EOT*+\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\b\DC2\EOT\189\EOT,=\n\ + \\r\n\ + \\ENQ\EOT\v\STX\NUL\a\DC2\EOT\189\EOT7<\n\ + \\235\SOH\n\ + \\EOT\EOT\v\STX\SOH\DC2\EOT\194\EOT\STXF\SUB\220\SOH Disables the generation of the standard \"descriptor()\" accessor, which can\n\ + \ conflict with a field of the same name. This is meant to make migration\n\ + \ from proto1 easier; new code should avoid fields named \"descriptor\".\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\EOT\DC2\EOT\194\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\ENQ\DC2\EOT\194\EOT\v\SI\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\SOH\DC2\EOT\194\EOT\DLE/\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\ETX\DC2\EOT\194\EOT23\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\b\DC2\EOT\194\EOT4E\n\ + \\r\n\ + \\ENQ\EOT\v\STX\SOH\a\DC2\EOT\194\EOT?D\n\ + \\238\SOH\n\ + \\EOT\EOT\v\STX\STX\DC2\EOT\200\EOT\STX1\SUB\223\SOH Is this message deprecated?\n\ + \ Depending on the target platform, this can emit Deprecated annotations\n\ + \ for the message, or it will be completely ignored; in the very least,\n\ + \ this is a formalization for deprecating messages.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\EOT\DC2\EOT\200\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\ENQ\DC2\EOT\200\EOT\v\SI\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\SOH\DC2\EOT\200\EOT\DLE\SUB\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\ETX\DC2\EOT\200\EOT\GS\RS\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\b\DC2\EOT\200\EOT\US0\n\ + \\r\n\ + \\ENQ\EOT\v\STX\STX\a\DC2\EOT\200\EOT*/\n\ + \\v\n\ + \\ETX\EOT\v\t\DC2\EOT\202\EOT\STX\DC3\n\ + \\f\n\ + \\EOT\EOT\v\t\NUL\DC2\EOT\202\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\NUL\SOH\DC2\EOT\202\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\NUL\STX\DC2\EOT\202\EOT\v\f\n\ + \\f\n\ + \\EOT\EOT\v\t\SOH\DC2\EOT\202\EOT\SO\SI\n\ + \\r\n\ + \\ENQ\EOT\v\t\SOH\SOH\DC2\EOT\202\EOT\SO\SI\n\ + \\r\n\ + \\ENQ\EOT\v\t\SOH\STX\DC2\EOT\202\EOT\SO\SI\n\ + \\f\n\ + \\EOT\EOT\v\t\STX\DC2\EOT\202\EOT\DC1\DC2\n\ + \\r\n\ + \\ENQ\EOT\v\t\STX\SOH\DC2\EOT\202\EOT\DC1\DC2\n\ + \\r\n\ + \\ENQ\EOT\v\t\STX\STX\DC2\EOT\202\EOT\DC1\DC2\n\ + \\160\ACK\n\ + \\EOT\EOT\v\STX\ETX\DC2\EOT\225\EOT\STX\RS\SUB\145\ACK Whether the message is an automatically generated map entry type for the\n\ + \ maps field.\n\ + \\n\ + \ For maps fields:\n\ + \ map map_field = 1;\n\ + \ The parsed descriptor looks like:\n\ + \ message MapFieldEntry {\n\ + \ option map_entry = true;\n\ + \ optional KeyType key = 1;\n\ + \ optional ValueType value = 2;\n\ + \ }\n\ + \ repeated MapFieldEntry map_field = 1;\n\ + \\n\ + \ Implementations may choose not to generate the map_entry=true message, but\n\ + \ use a native map in the target language to hold the keys and values.\n\ + \ The reflection APIs in such implementations still need to work as\n\ + \ if the field is a repeated message field.\n\ + \\n\ + \ NOTE: Do not set the option in .proto files. Always use the maps syntax\n\ + \ instead. The option should only be implicitly set by the proto compiler\n\ + \ parser.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\ETX\EOT\DC2\EOT\225\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\ETX\ENQ\DC2\EOT\225\EOT\v\SI\n\ + \\r\n\ + \\ENQ\EOT\v\STX\ETX\SOH\DC2\EOT\225\EOT\DLE\EM\n\ + \\r\n\ + \\ENQ\EOT\v\STX\ETX\ETX\DC2\EOT\225\EOT\FS\GS\n\ + \$\n\ + \\ETX\EOT\v\t\DC2\EOT\227\EOT\STX\r\"\ETB javalite_serializable\n\ + \\n\ + \\f\n\ + \\EOT\EOT\v\t\ETX\DC2\EOT\227\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\ETX\SOH\DC2\EOT\227\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\ETX\STX\DC2\EOT\227\EOT\v\f\n\ + \\US\n\ + \\ETX\EOT\v\t\DC2\EOT\228\EOT\STX\r\"\DC2 javanano_as_lite\n\ + \\n\ + \\f\n\ + \\EOT\EOT\v\t\EOT\DC2\EOT\228\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\EOT\SOH\DC2\EOT\228\EOT\v\f\n\ + \\r\n\ + \\ENQ\EOT\v\t\EOT\STX\DC2\EOT\228\EOT\v\f\n\ + \\221\ETX\n\ + \\EOT\EOT\v\STX\EOT\DC2\EOT\240\EOT\STXP\SUB\206\ETX Enable the legacy handling of JSON field name conflicts. This lowercases\n\ + \ and strips underscored from the fields before comparison in proto3 only.\n\ + \ The new behavior takes `json_name` into account and applies to proto2 as\n\ + \ well.\n\ + \\n\ + \ This should only be used as a temporary measure against broken builds due\n\ + \ to the change in behavior for JSON field name conflicts.\n\ + \\n\ + \ TODO This is legacy behavior we plan to remove once downstream\n\ + \ teams have had time to migrate.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\EOT\EOT\DC2\EOT\240\EOT\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\v\STX\EOT\ENQ\DC2\EOT\240\EOT\v\SI\n\ + \\r\n\ + \\ENQ\EOT\v\STX\EOT\SOH\DC2\EOT\240\EOT\DLE6\n\ + \\r\n\ + \\ENQ\EOT\v\STX\EOT\ETX\DC2\EOT\240\EOT9;\n\ + \\r\n\ + \\ENQ\EOT\v\STX\EOT\b\DC2\EOT\240\EOT Defaults of features that can be overridden in this edition.\n\ + \\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\SOH\EOT\DC2\EOT\208\b\EOT\f\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\SOH\ACK\DC2\EOT\208\b\r\ETB\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\SOH\SOH\DC2\EOT\208\b\CAN,\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\SOH\ETX\DC2\EOT\208\b/0\n\ + \P\n\ + \\ACK\EOT\DC4\ETX\NUL\STX\STX\DC2\EOT\211\b\EOT+\SUB@ Defaults of features that can't be overridden in this edition.\n\ + \\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\STX\EOT\DC2\EOT\211\b\EOT\f\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\STX\ACK\DC2\EOT\211\b\r\ETB\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\STX\SOH\DC2\EOT\211\b\CAN&\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\STX\STX\ETX\DC2\EOT\211\b)*\n\ + \\r\n\ + \\ENQ\EOT\DC4\ETX\NUL\t\DC2\EOT\213\b\EOT\DC2\n\ + \\SO\n\ + \\ACK\EOT\DC4\ETX\NUL\t\NUL\DC2\EOT\213\b\r\SO\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\t\NUL\SOH\DC2\EOT\213\b\r\SO\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\t\NUL\STX\DC2\EOT\213\b\r\SO\n\ + \\SO\n\ + \\ACK\EOT\DC4\ETX\NUL\t\SOH\DC2\EOT\213\b\DLE\DC1\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\t\SOH\SOH\DC2\EOT\213\b\DLE\DC1\n\ + \\SI\n\ + \\a\EOT\DC4\ETX\NUL\t\SOH\STX\DC2\EOT\213\b\DLE\DC1\n\ + \\r\n\ + \\ENQ\EOT\DC4\ETX\NUL\n\ + \\DC2\EOT\214\b\EOT\CAN\n\ + \\SO\n\ + \\ACK\EOT\DC4\ETX\NUL\n\ + \\NUL\DC2\EOT\214\b\r\ETB\n\ + \\f\n\ + \\EOT\EOT\DC4\STX\NUL\DC2\EOT\216\b\STX1\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\NUL\EOT\DC2\EOT\216\b\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\NUL\ACK\DC2\EOT\216\b\v#\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\NUL\SOH\DC2\EOT\216\b$,\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\NUL\ETX\DC2\EOT\216\b/0\n\ + \\130\SOH\n\ + \\EOT\EOT\DC4\STX\SOH\DC2\EOT\220\b\STX'\SUBt The minimum supported edition (inclusive) when this was constructed.\n\ + \ Editions before this will not have defaults.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\SOH\EOT\DC2\EOT\220\b\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\SOH\ACK\DC2\EOT\220\b\v\DC2\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\SOH\SOH\DC2\EOT\220\b\DC3\"\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\SOH\ETX\DC2\EOT\220\b%&\n\ + \\134\SOH\n\ + \\EOT\EOT\DC4\STX\STX\DC2\EOT\224\b\STX'\SUBx The maximum known edition (inclusive) when this was constructed. Editions\n\ + \ after this will not have reliable defaults.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\STX\EOT\DC2\EOT\224\b\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\STX\ACK\DC2\EOT\224\b\v\DC2\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\STX\SOH\DC2\EOT\224\b\DC3\"\n\ + \\r\n\ + \\ENQ\EOT\DC4\STX\STX\ETX\DC2\EOT\224\b%&\n\ + \\218\SOH\n\ + \\STX\EOT\NAK\DC2\ACK\232\b\NUL\233\t\SOH\SUBj Encapsulates information about the original source file from which a\n\ + \ FileDescriptorProto was generated.\n\ + \2` ===================================================================\n\ + \ Optional source code info\n\ + \\n\ + \\v\n\ + \\ETX\EOT\NAK\SOH\DC2\EOT\232\b\b\SYN\n\ + \\130\DC1\n\ + \\EOT\EOT\NAK\STX\NUL\DC2\EOT\148\t\STX!\SUB\243\DLE A Location identifies a piece of source code in a .proto file which\n\ + \ corresponds to a particular definition. This information is intended\n\ + \ to be useful to IDEs, code indexers, documentation generators, and similar\n\ + \ tools.\n\ + \\n\ + \ For example, say we have a file like:\n\ + \ message Foo {\n\ + \ optional string foo = 1;\n\ + \ }\n\ + \ Let's look at just the field definition:\n\ + \ optional string foo = 1;\n\ + \ ^ ^^ ^^ ^ ^^^\n\ + \ a bc de f ghi\n\ + \ We have the following locations:\n\ + \ span path represents\n\ + \ [a,i) [ 4, 0, 2, 0 ] The whole field definition.\n\ + \ [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).\n\ + \ [c,d) [ 4, 0, 2, 0, 5 ] The type (string).\n\ + \ [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).\n\ + \ [g,h) [ 4, 0, 2, 0, 3 ] The number (1).\n\ + \\n\ + \ Notes:\n\ + \ - A location may refer to a repeated field itself (i.e. not to any\n\ + \ particular index within it). This is used whenever a set of elements are\n\ + \ logically enclosed in a single code segment. For example, an entire\n\ + \ extend block (possibly containing multiple extension definitions) will\n\ + \ have an outer location whose path refers to the \"extensions\" repeated\n\ + \ field without an index.\n\ + \ - Multiple locations may have the same path. This happens when a single\n\ + \ logical declaration is spread out across multiple places. The most\n\ + \ obvious example is the \"extend\" block again -- there may be multiple\n\ + \ extend blocks in the same scope, each of which will have the same path.\n\ + \ - A location's span is not always a subset of its parent's span. For\n\ + \ example, the \"extendee\" of an extension declaration appears at the\n\ + \ beginning of the \"extend\" block and is shared by all extensions within\n\ + \ the block.\n\ + \ - Just because a location's span is a subset of some other location's span\n\ + \ does not mean that it is a descendant. For example, a \"group\" defines\n\ + \ both a type and a field in a single declaration. Thus, the locations\n\ + \ corresponding to the type and field and their components will overlap.\n\ + \ - Code which tries to interpret locations should probably be designed to\n\ + \ ignore those that it doesn't understand, as more types of locations could\n\ + \ be recorded in the future.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\NAK\STX\NUL\EOT\DC2\EOT\148\t\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\NAK\STX\NUL\ACK\DC2\EOT\148\t\v\DC3\n\ + \\r\n\ + \\ENQ\EOT\NAK\STX\NUL\SOH\DC2\EOT\148\t\DC4\FS\n\ + \\r\n\ + \\ENQ\EOT\NAK\STX\NUL\ETX\DC2\EOT\148\t\US \n\ + \\SO\n\ + \\EOT\EOT\NAK\ETX\NUL\DC2\ACK\149\t\STX\232\t\ETX\n\ + \\r\n\ + \\ENQ\EOT\NAK\ETX\NUL\SOH\DC2\EOT\149\t\n\ + \\DC2\n\ + \\138\a\n\ + \\ACK\EOT\NAK\ETX\NUL\STX\NUL\DC2\EOT\173\t\EOT,\SUB\249\ACK Identifies which part of the FileDescriptorProto was defined at this\n\ + \ location.\n\ + \\n\ + \ Each element is a field number or an index. They form a path from\n\ + \ the root FileDescriptorProto to the place where the definition appears.\n\ + \ For example, this path:\n\ + \ [ 4, 3, 2, 7, 1 ]\n\ + \ refers to:\n\ + \ file.message_type(3) // 4, 3\n\ + \ .field(7) // 2, 7\n\ + \ .name() // 1\n\ + \ This is because FileDescriptorProto.message_type has field number 4:\n\ + \ repeated DescriptorProto message_type = 4;\n\ + \ and DescriptorProto.field has field number 2:\n\ + \ repeated FieldDescriptorProto field = 2;\n\ + \ and FieldDescriptorProto.name has field number 1:\n\ + \ optional string name = 1;\n\ + \\n\ + \ Thus, the above path gives the location of a field name. If we removed\n\ + \ the last element:\n\ + \ [ 4, 3, 2, 7 ]\n\ + \ this path refers to the whole field declaration (from the beginning\n\ + \ of the label to the terminating semicolon).\n\ + \\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\NUL\EOT\DC2\EOT\173\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\NUL\ENQ\DC2\EOT\173\t\r\DC2\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\NUL\SOH\DC2\EOT\173\t\DC3\ETB\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\NUL\ETX\DC2\EOT\173\t\SUB\ESC\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\NUL\b\DC2\EOT\173\t\FS+\n\ + \\DLE\n\ + \\b\EOT\NAK\ETX\NUL\STX\NUL\b\STX\DC2\EOT\173\t\GS*\n\ + \\210\STX\n\ + \\ACK\EOT\NAK\ETX\NUL\STX\SOH\DC2\EOT\180\t\EOT,\SUB\193\STX Always has exactly three or four elements: start line, start column,\n\ + \ end line (optional, otherwise assumed same as start line), end column.\n\ + \ These are packed into a single field for efficiency. Note that line\n\ + \ and column numbers are zero-based -- typically you will want to add\n\ + \ 1 to each before displaying to a user.\n\ + \\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\SOH\EOT\DC2\EOT\180\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\SOH\ENQ\DC2\EOT\180\t\r\DC2\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\SOH\SOH\DC2\EOT\180\t\DC3\ETB\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\SOH\ETX\DC2\EOT\180\t\SUB\ESC\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\SOH\b\DC2\EOT\180\t\FS+\n\ + \\DLE\n\ + \\b\EOT\NAK\ETX\NUL\STX\SOH\b\STX\DC2\EOT\180\t\GS*\n\ + \\165\f\n\ + \\ACK\EOT\NAK\ETX\NUL\STX\STX\DC2\EOT\229\t\EOT)\SUB\148\f If this SourceCodeInfo represents a complete declaration, these are any\n\ + \ comments appearing before and after the declaration which appear to be\n\ + \ attached to the declaration.\n\ + \\n\ + \ A series of line comments appearing on consecutive lines, with no other\n\ + \ tokens appearing on those lines, will be treated as a single comment.\n\ + \\n\ + \ leading_detached_comments will keep paragraphs of comments that appear\n\ + \ before (but not connected to) the current element. Each paragraph,\n\ + \ separated by empty lines, will be one comment element in the repeated\n\ + \ field.\n\ + \\n\ + \ Only the comment content is provided; comment markers (e.g. //) are\n\ + \ stripped out. For block comments, leading whitespace and an asterisk\n\ + \ will be stripped from the beginning of each line other than the first.\n\ + \ Newlines are included in the output.\n\ + \\n\ + \ Examples:\n\ + \\n\ + \ optional int32 foo = 1; // Comment attached to foo.\n\ + \ // Comment attached to bar.\n\ + \ optional int32 bar = 2;\n\ + \\n\ + \ optional string baz = 3;\n\ + \ // Comment attached to baz.\n\ + \ // Another line attached to baz.\n\ + \\n\ + \ // Comment attached to moo.\n\ + \ //\n\ + \ // Another line attached to moo.\n\ + \ optional double moo = 4;\n\ + \\n\ + \ // Detached comment for corge. This is not leading or trailing comments\n\ + \ // to moo or corge because there are blank lines separating it from\n\ + \ // both.\n\ + \\n\ + \ // Detached comment for corge paragraph 2.\n\ + \\n\ + \ optional string corge = 5;\n\ + \ /* Block comment attached\n\ + \ * to corge. Leading asterisks\n\ + \ * will be removed. */\n\ + \ /* Block comment attached to\n\ + \ * grault. */\n\ + \ optional int32 grault = 6;\n\ + \\n\ + \ // ignored detached comments.\n\ + \\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\STX\EOT\DC2\EOT\229\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\STX\ENQ\DC2\EOT\229\t\r\DC3\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\STX\SOH\DC2\EOT\229\t\DC4$\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\STX\ETX\DC2\EOT\229\t'(\n\ + \\SO\n\ + \\ACK\EOT\NAK\ETX\NUL\STX\ETX\DC2\EOT\230\t\EOT*\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\ETX\EOT\DC2\EOT\230\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\ETX\ENQ\DC2\EOT\230\t\r\DC3\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\ETX\SOH\DC2\EOT\230\t\DC4%\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\ETX\ETX\DC2\EOT\230\t()\n\ + \\SO\n\ + \\ACK\EOT\NAK\ETX\NUL\STX\EOT\DC2\EOT\231\t\EOT2\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\EOT\EOT\DC2\EOT\231\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\EOT\ENQ\DC2\EOT\231\t\r\DC3\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\EOT\SOH\DC2\EOT\231\t\DC4-\n\ + \\SI\n\ + \\a\EOT\NAK\ETX\NUL\STX\EOT\ETX\DC2\EOT\231\t01\n\ + \\238\SOH\n\ + \\STX\EOT\SYN\DC2\ACK\238\t\NUL\143\n\ + \\SOH\SUB\223\SOH Describes the relationship between generated code and its original source\n\ + \ file. A GeneratedCodeInfo message is associated with only one generated\n\ + \ source file, but may contain references to different source .proto files.\n\ + \\n\ + \\v\n\ + \\ETX\EOT\SYN\SOH\DC2\EOT\238\t\b\EM\n\ + \x\n\ + \\EOT\EOT\SYN\STX\NUL\DC2\EOT\241\t\STX%\SUBj An Annotation connects some span of text in generated code to an element\n\ + \ of its generating .proto file.\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\SYN\STX\NUL\EOT\DC2\EOT\241\t\STX\n\ + \\n\ + \\r\n\ + \\ENQ\EOT\SYN\STX\NUL\ACK\DC2\EOT\241\t\v\NAK\n\ + \\r\n\ + \\ENQ\EOT\SYN\STX\NUL\SOH\DC2\EOT\241\t\SYN \n\ + \\r\n\ + \\ENQ\EOT\SYN\STX\NUL\ETX\DC2\EOT\241\t#$\n\ + \\SO\n\ + \\EOT\EOT\SYN\ETX\NUL\DC2\ACK\242\t\STX\142\n\ + \\ETX\n\ + \\r\n\ + \\ENQ\EOT\SYN\ETX\NUL\SOH\DC2\EOT\242\t\n\ + \\DC4\n\ + \\143\SOH\n\ + \\ACK\EOT\SYN\ETX\NUL\STX\NUL\DC2\EOT\245\t\EOT,\SUB\DEL Identifies the element in the original source .proto file. This field\n\ + \ is formatted the same as SourceCodeInfo.Location.path.\n\ + \\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\NUL\EOT\DC2\EOT\245\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\NUL\ENQ\DC2\EOT\245\t\r\DC2\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\NUL\SOH\DC2\EOT\245\t\DC3\ETB\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\NUL\ETX\DC2\EOT\245\t\SUB\ESC\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\NUL\b\DC2\EOT\245\t\FS+\n\ + \\DLE\n\ + \\b\EOT\SYN\ETX\NUL\STX\NUL\b\STX\DC2\EOT\245\t\GS*\n\ + \O\n\ + \\ACK\EOT\SYN\ETX\NUL\STX\SOH\DC2\EOT\248\t\EOT$\SUB? Identifies the filesystem path to the original source .proto.\n\ + \\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\SOH\EOT\DC2\EOT\248\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\SOH\ENQ\DC2\EOT\248\t\r\DC3\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\SOH\SOH\DC2\EOT\248\t\DC4\US\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\SOH\ETX\DC2\EOT\248\t\"#\n\ + \w\n\ + \\ACK\EOT\SYN\ETX\NUL\STX\STX\DC2\EOT\252\t\EOT\GS\SUBg Identifies the starting offset in bytes in the generated code\n\ + \ that relates to the identified object.\n\ + \\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\STX\EOT\DC2\EOT\252\t\EOT\f\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\STX\ENQ\DC2\EOT\252\t\r\DC2\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\STX\SOH\DC2\EOT\252\t\DC3\CAN\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\STX\ETX\DC2\EOT\252\t\ESC\FS\n\ + \\219\SOH\n\ + \\ACK\EOT\SYN\ETX\NUL\STX\ETX\DC2\EOT\129\n\ + \\EOT\ESC\SUB\202\SOH Identifies the ending offset in bytes in the generated code that\n\ + \ relates to the identified object. The end offset should be one past\n\ + \ the last relevant byte (so the length of the text = end - begin).\n\ + \\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\ETX\EOT\DC2\EOT\129\n\ + \\EOT\f\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\ETX\ENQ\DC2\EOT\129\n\ + \\r\DC2\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\ETX\SOH\DC2\EOT\129\n\ + \\DC3\SYN\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\ETX\ETX\DC2\EOT\129\n\ + \\EM\SUB\n\ + \j\n\ + \\ACK\EOT\SYN\ETX\NUL\EOT\NUL\DC2\ACK\133\n\ + \\EOT\140\n\ + \\ENQ\SUBX Represents the identified object's effect on the element in the original\n\ + \ .proto file.\n\ + \\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\EOT\NUL\SOH\DC2\EOT\133\n\ + \\t\DC1\n\ + \F\n\ + \\b\EOT\SYN\ETX\NUL\EOT\NUL\STX\NUL\DC2\EOT\135\n\ + \\ACK\SI\SUB4 There is no effect or the effect is indescribable.\n\ + \\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\NUL\SOH\DC2\EOT\135\n\ + \\ACK\n\ + \\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\NUL\STX\DC2\EOT\135\n\ + \\r\SO\n\ + \<\n\ + \\b\EOT\SYN\ETX\NUL\EOT\NUL\STX\SOH\DC2\EOT\137\n\ + \\ACK\SO\SUB* The element is set or otherwise mutated.\n\ + \\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\SOH\SOH\DC2\EOT\137\n\ + \\ACK\t\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\SOH\STX\DC2\EOT\137\n\ + \\f\r\n\ + \8\n\ + \\b\EOT\SYN\ETX\NUL\EOT\NUL\STX\STX\DC2\EOT\139\n\ + \\ACK\DLE\SUB& An alias to the element is returned.\n\ + \\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\STX\SOH\DC2\EOT\139\n\ + \\ACK\v\n\ + \\DC1\n\ + \\t\EOT\SYN\ETX\NUL\EOT\NUL\STX\STX\STX\DC2\EOT\139\n\ + \\SO\SI\n\ + \\SO\n\ + \\ACK\EOT\SYN\ETX\NUL\STX\EOT\DC2\EOT\141\n\ + \\EOT#\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\EOT\EOT\DC2\EOT\141\n\ + \\EOT\f\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\EOT\ACK\DC2\EOT\141\n\ + \\r\NAK\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\EOT\SOH\DC2\EOT\141\n\ + \\SYN\RS\n\ + \\SI\n\ + \\a\EOT\SYN\ETX\NUL\STX\EOT\ETX\DC2\EOT\141\n\ + \!\"" diff --git a/app/Proto/Google/Protobuf/Descriptor_Fields.hs b/app/Proto/Google/Protobuf/Descriptor_Fields.hs new file mode 100644 --- /dev/null +++ b/app/Proto/Google/Protobuf/Descriptor_Fields.hs @@ -0,0 +1,1418 @@ +{- 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, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-} +{-# OPTIONS_GHC -Wno-unused-imports#-} +{-# OPTIONS_GHC -Wno-duplicate-exports#-} +{-# OPTIONS_GHC -Wno-dodgy-exports#-} +module Proto.Google.Protobuf.Descriptor_Fields where +import qualified Data.ProtoLens.Runtime.Prelude as Prelude +import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int +import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid +import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word +import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types +import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2 +import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text +import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map +import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString +import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8 +import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding +import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector +import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic +import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed +import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read +aggregateValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "aggregateValue" a) => + Lens.Family2.LensLike' f s a +aggregateValue = Data.ProtoLens.Field.field @"aggregateValue" +allowAlias :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "allowAlias" a) => + Lens.Family2.LensLike' f s a +allowAlias = Data.ProtoLens.Field.field @"allowAlias" +annotation :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "annotation" a) => + Lens.Family2.LensLike' f s a +annotation = Data.ProtoLens.Field.field @"annotation" +begin :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "begin" a) => + Lens.Family2.LensLike' f s a +begin = Data.ProtoLens.Field.field @"begin" +ccEnableArenas :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "ccEnableArenas" a) => + Lens.Family2.LensLike' f s a +ccEnableArenas = Data.ProtoLens.Field.field @"ccEnableArenas" +ccGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "ccGenericServices" a) => + Lens.Family2.LensLike' f s a +ccGenericServices = Data.ProtoLens.Field.field @"ccGenericServices" +clientStreaming :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "clientStreaming" a) => + Lens.Family2.LensLike' f s a +clientStreaming = Data.ProtoLens.Field.field @"clientStreaming" +csharpNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "csharpNamespace" a) => + Lens.Family2.LensLike' f s a +csharpNamespace = Data.ProtoLens.Field.field @"csharpNamespace" +ctype :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "ctype" a) => + Lens.Family2.LensLike' f s a +ctype = Data.ProtoLens.Field.field @"ctype" +debugRedact :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "debugRedact" a) => + Lens.Family2.LensLike' f s a +debugRedact = Data.ProtoLens.Field.field @"debugRedact" +declaration :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "declaration" a) => + Lens.Family2.LensLike' f s a +declaration = Data.ProtoLens.Field.field @"declaration" +defaultValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "defaultValue" a) => + Lens.Family2.LensLike' f s a +defaultValue = Data.ProtoLens.Field.field @"defaultValue" +defaults :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "defaults" a) => + Lens.Family2.LensLike' f s a +defaults = Data.ProtoLens.Field.field @"defaults" +dependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "dependency" a) => + Lens.Family2.LensLike' f s a +dependency = Data.ProtoLens.Field.field @"dependency" +deprecated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "deprecated" a) => + Lens.Family2.LensLike' f s a +deprecated = Data.ProtoLens.Field.field @"deprecated" +deprecatedLegacyJsonFieldConflicts :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "deprecatedLegacyJsonFieldConflicts" a) => + Lens.Family2.LensLike' f s a +deprecatedLegacyJsonFieldConflicts + = Data.ProtoLens.Field.field @"deprecatedLegacyJsonFieldConflicts" +deprecationWarning :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "deprecationWarning" a) => + Lens.Family2.LensLike' f s a +deprecationWarning + = Data.ProtoLens.Field.field @"deprecationWarning" +doubleValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "doubleValue" a) => + Lens.Family2.LensLike' f s a +doubleValue = Data.ProtoLens.Field.field @"doubleValue" +edition :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "edition" a) => + Lens.Family2.LensLike' f s a +edition = Data.ProtoLens.Field.field @"edition" +editionDefaults :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "editionDefaults" a) => + Lens.Family2.LensLike' f s a +editionDefaults = Data.ProtoLens.Field.field @"editionDefaults" +editionDeprecated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "editionDeprecated" a) => + Lens.Family2.LensLike' f s a +editionDeprecated = Data.ProtoLens.Field.field @"editionDeprecated" +editionIntroduced :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "editionIntroduced" a) => + Lens.Family2.LensLike' f s a +editionIntroduced = Data.ProtoLens.Field.field @"editionIntroduced" +editionRemoved :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "editionRemoved" a) => + Lens.Family2.LensLike' f s a +editionRemoved = Data.ProtoLens.Field.field @"editionRemoved" +end :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "end" a) => + Lens.Family2.LensLike' f s a +end = Data.ProtoLens.Field.field @"end" +enumType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "enumType" a) => + Lens.Family2.LensLike' f s a +enumType = Data.ProtoLens.Field.field @"enumType" +extendee :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "extendee" a) => + Lens.Family2.LensLike' f s a +extendee = Data.ProtoLens.Field.field @"extendee" +extension :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "extension" a) => + Lens.Family2.LensLike' f s a +extension = Data.ProtoLens.Field.field @"extension" +extensionRange :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "extensionRange" a) => + Lens.Family2.LensLike' f s a +extensionRange = Data.ProtoLens.Field.field @"extensionRange" +featureSupport :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "featureSupport" a) => + Lens.Family2.LensLike' f s a +featureSupport = Data.ProtoLens.Field.field @"featureSupport" +features :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "features" a) => + Lens.Family2.LensLike' f s a +features = Data.ProtoLens.Field.field @"features" +field :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "field" a) => + Lens.Family2.LensLike' f s a +field = Data.ProtoLens.Field.field @"field" +fieldPresence :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "fieldPresence" a) => + Lens.Family2.LensLike' f s a +fieldPresence = Data.ProtoLens.Field.field @"fieldPresence" +file :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "file" a) => + Lens.Family2.LensLike' f s a +file = Data.ProtoLens.Field.field @"file" +fixedFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "fixedFeatures" a) => + Lens.Family2.LensLike' f s a +fixedFeatures = Data.ProtoLens.Field.field @"fixedFeatures" +fullName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "fullName" a) => + Lens.Family2.LensLike' f s a +fullName = Data.ProtoLens.Field.field @"fullName" +goPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "goPackage" a) => + Lens.Family2.LensLike' f s a +goPackage = Data.ProtoLens.Field.field @"goPackage" +idempotencyLevel :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "idempotencyLevel" a) => + Lens.Family2.LensLike' f s a +idempotencyLevel = Data.ProtoLens.Field.field @"idempotencyLevel" +identifierValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "identifierValue" a) => + Lens.Family2.LensLike' f s a +identifierValue = Data.ProtoLens.Field.field @"identifierValue" +inputType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "inputType" a) => + Lens.Family2.LensLike' f s a +inputType = Data.ProtoLens.Field.field @"inputType" +isExtension :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "isExtension" a) => + Lens.Family2.LensLike' f s a +isExtension = Data.ProtoLens.Field.field @"isExtension" +javaGenerateEqualsAndHash :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaGenerateEqualsAndHash" a) => + Lens.Family2.LensLike' f s a +javaGenerateEqualsAndHash + = Data.ProtoLens.Field.field @"javaGenerateEqualsAndHash" +javaGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaGenericServices" a) => + Lens.Family2.LensLike' f s a +javaGenericServices + = Data.ProtoLens.Field.field @"javaGenericServices" +javaMultipleFiles :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaMultipleFiles" a) => + Lens.Family2.LensLike' f s a +javaMultipleFiles = Data.ProtoLens.Field.field @"javaMultipleFiles" +javaOuterClassname :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaOuterClassname" a) => + Lens.Family2.LensLike' f s a +javaOuterClassname + = Data.ProtoLens.Field.field @"javaOuterClassname" +javaPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaPackage" a) => + Lens.Family2.LensLike' f s a +javaPackage = Data.ProtoLens.Field.field @"javaPackage" +javaStringCheckUtf8 :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "javaStringCheckUtf8" a) => + Lens.Family2.LensLike' f s a +javaStringCheckUtf8 + = Data.ProtoLens.Field.field @"javaStringCheckUtf8" +jsonFormat :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "jsonFormat" a) => + Lens.Family2.LensLike' f s a +jsonFormat = Data.ProtoLens.Field.field @"jsonFormat" +jsonName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "jsonName" a) => + Lens.Family2.LensLike' f s a +jsonName = Data.ProtoLens.Field.field @"jsonName" +jstype :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "jstype" a) => + Lens.Family2.LensLike' f s a +jstype = Data.ProtoLens.Field.field @"jstype" +label :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "label" a) => + Lens.Family2.LensLike' f s a +label = Data.ProtoLens.Field.field @"label" +lazy :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "lazy" a) => + Lens.Family2.LensLike' f s a +lazy = Data.ProtoLens.Field.field @"lazy" +leadingComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "leadingComments" a) => + Lens.Family2.LensLike' f s a +leadingComments = Data.ProtoLens.Field.field @"leadingComments" +leadingDetachedComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "leadingDetachedComments" a) => + Lens.Family2.LensLike' f s a +leadingDetachedComments + = Data.ProtoLens.Field.field @"leadingDetachedComments" +location :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "location" a) => + Lens.Family2.LensLike' f s a +location = Data.ProtoLens.Field.field @"location" +mapEntry :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "mapEntry" a) => + Lens.Family2.LensLike' f s a +mapEntry = Data.ProtoLens.Field.field @"mapEntry" +maximumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maximumEdition" a) => + Lens.Family2.LensLike' f s a +maximumEdition = Data.ProtoLens.Field.field @"maximumEdition" +maybe'aggregateValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'aggregateValue" a) => + Lens.Family2.LensLike' f s a +maybe'aggregateValue + = Data.ProtoLens.Field.field @"maybe'aggregateValue" +maybe'allowAlias :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'allowAlias" a) => + Lens.Family2.LensLike' f s a +maybe'allowAlias = Data.ProtoLens.Field.field @"maybe'allowAlias" +maybe'begin :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'begin" a) => + Lens.Family2.LensLike' f s a +maybe'begin = Data.ProtoLens.Field.field @"maybe'begin" +maybe'ccEnableArenas :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'ccEnableArenas" a) => + Lens.Family2.LensLike' f s a +maybe'ccEnableArenas + = Data.ProtoLens.Field.field @"maybe'ccEnableArenas" +maybe'ccGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'ccGenericServices" a) => + Lens.Family2.LensLike' f s a +maybe'ccGenericServices + = Data.ProtoLens.Field.field @"maybe'ccGenericServices" +maybe'clientStreaming :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'clientStreaming" a) => + Lens.Family2.LensLike' f s a +maybe'clientStreaming + = Data.ProtoLens.Field.field @"maybe'clientStreaming" +maybe'csharpNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'csharpNamespace" a) => + Lens.Family2.LensLike' f s a +maybe'csharpNamespace + = Data.ProtoLens.Field.field @"maybe'csharpNamespace" +maybe'ctype :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'ctype" a) => + Lens.Family2.LensLike' f s a +maybe'ctype = Data.ProtoLens.Field.field @"maybe'ctype" +maybe'debugRedact :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'debugRedact" a) => + Lens.Family2.LensLike' f s a +maybe'debugRedact = Data.ProtoLens.Field.field @"maybe'debugRedact" +maybe'defaultValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'defaultValue" a) => + Lens.Family2.LensLike' f s a +maybe'defaultValue + = Data.ProtoLens.Field.field @"maybe'defaultValue" +maybe'deprecated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'deprecated" a) => + Lens.Family2.LensLike' f s a +maybe'deprecated = Data.ProtoLens.Field.field @"maybe'deprecated" +maybe'deprecatedLegacyJsonFieldConflicts :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'deprecatedLegacyJsonFieldConflicts" a) => + Lens.Family2.LensLike' f s a +maybe'deprecatedLegacyJsonFieldConflicts + = Data.ProtoLens.Field.field + @"maybe'deprecatedLegacyJsonFieldConflicts" +maybe'deprecationWarning :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'deprecationWarning" a) => + Lens.Family2.LensLike' f s a +maybe'deprecationWarning + = Data.ProtoLens.Field.field @"maybe'deprecationWarning" +maybe'doubleValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'doubleValue" a) => + Lens.Family2.LensLike' f s a +maybe'doubleValue = Data.ProtoLens.Field.field @"maybe'doubleValue" +maybe'edition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'edition" a) => + Lens.Family2.LensLike' f s a +maybe'edition = Data.ProtoLens.Field.field @"maybe'edition" +maybe'editionDeprecated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'editionDeprecated" a) => + Lens.Family2.LensLike' f s a +maybe'editionDeprecated + = Data.ProtoLens.Field.field @"maybe'editionDeprecated" +maybe'editionIntroduced :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'editionIntroduced" a) => + Lens.Family2.LensLike' f s a +maybe'editionIntroduced + = Data.ProtoLens.Field.field @"maybe'editionIntroduced" +maybe'editionRemoved :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'editionRemoved" a) => + Lens.Family2.LensLike' f s a +maybe'editionRemoved + = Data.ProtoLens.Field.field @"maybe'editionRemoved" +maybe'end :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'end" a) => + Lens.Family2.LensLike' f s a +maybe'end = Data.ProtoLens.Field.field @"maybe'end" +maybe'enumType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'enumType" a) => + Lens.Family2.LensLike' f s a +maybe'enumType = Data.ProtoLens.Field.field @"maybe'enumType" +maybe'extendee :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'extendee" a) => + Lens.Family2.LensLike' f s a +maybe'extendee = Data.ProtoLens.Field.field @"maybe'extendee" +maybe'featureSupport :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'featureSupport" a) => + Lens.Family2.LensLike' f s a +maybe'featureSupport + = Data.ProtoLens.Field.field @"maybe'featureSupport" +maybe'features :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'features" a) => + Lens.Family2.LensLike' f s a +maybe'features = Data.ProtoLens.Field.field @"maybe'features" +maybe'fieldPresence :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'fieldPresence" a) => + Lens.Family2.LensLike' f s a +maybe'fieldPresence + = Data.ProtoLens.Field.field @"maybe'fieldPresence" +maybe'fixedFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'fixedFeatures" a) => + Lens.Family2.LensLike' f s a +maybe'fixedFeatures + = Data.ProtoLens.Field.field @"maybe'fixedFeatures" +maybe'fullName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'fullName" a) => + Lens.Family2.LensLike' f s a +maybe'fullName = Data.ProtoLens.Field.field @"maybe'fullName" +maybe'goPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'goPackage" a) => + Lens.Family2.LensLike' f s a +maybe'goPackage = Data.ProtoLens.Field.field @"maybe'goPackage" +maybe'idempotencyLevel :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'idempotencyLevel" a) => + Lens.Family2.LensLike' f s a +maybe'idempotencyLevel + = Data.ProtoLens.Field.field @"maybe'idempotencyLevel" +maybe'identifierValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'identifierValue" a) => + Lens.Family2.LensLike' f s a +maybe'identifierValue + = Data.ProtoLens.Field.field @"maybe'identifierValue" +maybe'inputType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'inputType" a) => + Lens.Family2.LensLike' f s a +maybe'inputType = Data.ProtoLens.Field.field @"maybe'inputType" +maybe'javaGenerateEqualsAndHash :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaGenerateEqualsAndHash" a) => + Lens.Family2.LensLike' f s a +maybe'javaGenerateEqualsAndHash + = Data.ProtoLens.Field.field @"maybe'javaGenerateEqualsAndHash" +maybe'javaGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaGenericServices" a) => + Lens.Family2.LensLike' f s a +maybe'javaGenericServices + = Data.ProtoLens.Field.field @"maybe'javaGenericServices" +maybe'javaMultipleFiles :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaMultipleFiles" a) => + Lens.Family2.LensLike' f s a +maybe'javaMultipleFiles + = Data.ProtoLens.Field.field @"maybe'javaMultipleFiles" +maybe'javaOuterClassname :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaOuterClassname" a) => + Lens.Family2.LensLike' f s a +maybe'javaOuterClassname + = Data.ProtoLens.Field.field @"maybe'javaOuterClassname" +maybe'javaPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaPackage" a) => + Lens.Family2.LensLike' f s a +maybe'javaPackage = Data.ProtoLens.Field.field @"maybe'javaPackage" +maybe'javaStringCheckUtf8 :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'javaStringCheckUtf8" a) => + Lens.Family2.LensLike' f s a +maybe'javaStringCheckUtf8 + = Data.ProtoLens.Field.field @"maybe'javaStringCheckUtf8" +maybe'jsonFormat :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'jsonFormat" a) => + Lens.Family2.LensLike' f s a +maybe'jsonFormat = Data.ProtoLens.Field.field @"maybe'jsonFormat" +maybe'jsonName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'jsonName" a) => + Lens.Family2.LensLike' f s a +maybe'jsonName = Data.ProtoLens.Field.field @"maybe'jsonName" +maybe'jstype :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'jstype" a) => + Lens.Family2.LensLike' f s a +maybe'jstype = Data.ProtoLens.Field.field @"maybe'jstype" +maybe'label :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'label" a) => + Lens.Family2.LensLike' f s a +maybe'label = Data.ProtoLens.Field.field @"maybe'label" +maybe'lazy :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'lazy" a) => + Lens.Family2.LensLike' f s a +maybe'lazy = Data.ProtoLens.Field.field @"maybe'lazy" +maybe'leadingComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'leadingComments" a) => + Lens.Family2.LensLike' f s a +maybe'leadingComments + = Data.ProtoLens.Field.field @"maybe'leadingComments" +maybe'mapEntry :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'mapEntry" a) => + Lens.Family2.LensLike' f s a +maybe'mapEntry = Data.ProtoLens.Field.field @"maybe'mapEntry" +maybe'maximumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'maximumEdition" a) => + Lens.Family2.LensLike' f s a +maybe'maximumEdition + = Data.ProtoLens.Field.field @"maybe'maximumEdition" +maybe'messageEncoding :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'messageEncoding" a) => + Lens.Family2.LensLike' f s a +maybe'messageEncoding + = Data.ProtoLens.Field.field @"maybe'messageEncoding" +maybe'messageSetWireFormat :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'messageSetWireFormat" a) => + Lens.Family2.LensLike' f s a +maybe'messageSetWireFormat + = Data.ProtoLens.Field.field @"maybe'messageSetWireFormat" +maybe'minimumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'minimumEdition" a) => + Lens.Family2.LensLike' f s a +maybe'minimumEdition + = Data.ProtoLens.Field.field @"maybe'minimumEdition" +maybe'name :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'name" a) => + Lens.Family2.LensLike' f s a +maybe'name = Data.ProtoLens.Field.field @"maybe'name" +maybe'negativeIntValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'negativeIntValue" a) => + Lens.Family2.LensLike' f s a +maybe'negativeIntValue + = Data.ProtoLens.Field.field @"maybe'negativeIntValue" +maybe'noStandardDescriptorAccessor :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'noStandardDescriptorAccessor" a) => + Lens.Family2.LensLike' f s a +maybe'noStandardDescriptorAccessor + = Data.ProtoLens.Field.field @"maybe'noStandardDescriptorAccessor" +maybe'number :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'number" a) => + Lens.Family2.LensLike' f s a +maybe'number = Data.ProtoLens.Field.field @"maybe'number" +maybe'objcClassPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'objcClassPrefix" a) => + Lens.Family2.LensLike' f s a +maybe'objcClassPrefix + = Data.ProtoLens.Field.field @"maybe'objcClassPrefix" +maybe'oneofIndex :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'oneofIndex" a) => + Lens.Family2.LensLike' f s a +maybe'oneofIndex = Data.ProtoLens.Field.field @"maybe'oneofIndex" +maybe'optimizeFor :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'optimizeFor" a) => + Lens.Family2.LensLike' f s a +maybe'optimizeFor = Data.ProtoLens.Field.field @"maybe'optimizeFor" +maybe'options :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'options" a) => + Lens.Family2.LensLike' f s a +maybe'options = Data.ProtoLens.Field.field @"maybe'options" +maybe'outputType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'outputType" a) => + Lens.Family2.LensLike' f s a +maybe'outputType = Data.ProtoLens.Field.field @"maybe'outputType" +maybe'overridableFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'overridableFeatures" a) => + Lens.Family2.LensLike' f s a +maybe'overridableFeatures + = Data.ProtoLens.Field.field @"maybe'overridableFeatures" +maybe'package :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'package" a) => + Lens.Family2.LensLike' f s a +maybe'package = Data.ProtoLens.Field.field @"maybe'package" +maybe'packed :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'packed" a) => + Lens.Family2.LensLike' f s a +maybe'packed = Data.ProtoLens.Field.field @"maybe'packed" +maybe'phpClassPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'phpClassPrefix" a) => + Lens.Family2.LensLike' f s a +maybe'phpClassPrefix + = Data.ProtoLens.Field.field @"maybe'phpClassPrefix" +maybe'phpMetadataNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'phpMetadataNamespace" a) => + Lens.Family2.LensLike' f s a +maybe'phpMetadataNamespace + = Data.ProtoLens.Field.field @"maybe'phpMetadataNamespace" +maybe'phpNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'phpNamespace" a) => + Lens.Family2.LensLike' f s a +maybe'phpNamespace + = Data.ProtoLens.Field.field @"maybe'phpNamespace" +maybe'positiveIntValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'positiveIntValue" a) => + Lens.Family2.LensLike' f s a +maybe'positiveIntValue + = Data.ProtoLens.Field.field @"maybe'positiveIntValue" +maybe'proto3Optional :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'proto3Optional" a) => + Lens.Family2.LensLike' f s a +maybe'proto3Optional + = Data.ProtoLens.Field.field @"maybe'proto3Optional" +maybe'pyGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'pyGenericServices" a) => + Lens.Family2.LensLike' f s a +maybe'pyGenericServices + = Data.ProtoLens.Field.field @"maybe'pyGenericServices" +maybe'repeated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'repeated" a) => + Lens.Family2.LensLike' f s a +maybe'repeated = Data.ProtoLens.Field.field @"maybe'repeated" +maybe'repeatedFieldEncoding :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'repeatedFieldEncoding" a) => + Lens.Family2.LensLike' f s a +maybe'repeatedFieldEncoding + = Data.ProtoLens.Field.field @"maybe'repeatedFieldEncoding" +maybe'reserved :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'reserved" a) => + Lens.Family2.LensLike' f s a +maybe'reserved = Data.ProtoLens.Field.field @"maybe'reserved" +maybe'retention :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'retention" a) => + Lens.Family2.LensLike' f s a +maybe'retention = Data.ProtoLens.Field.field @"maybe'retention" +maybe'rubyPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'rubyPackage" a) => + Lens.Family2.LensLike' f s a +maybe'rubyPackage = Data.ProtoLens.Field.field @"maybe'rubyPackage" +maybe'semantic :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'semantic" a) => + Lens.Family2.LensLike' f s a +maybe'semantic = Data.ProtoLens.Field.field @"maybe'semantic" +maybe'serverStreaming :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'serverStreaming" a) => + Lens.Family2.LensLike' f s a +maybe'serverStreaming + = Data.ProtoLens.Field.field @"maybe'serverStreaming" +maybe'sourceCodeInfo :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'sourceCodeInfo" a) => + Lens.Family2.LensLike' f s a +maybe'sourceCodeInfo + = Data.ProtoLens.Field.field @"maybe'sourceCodeInfo" +maybe'sourceFile :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'sourceFile" a) => + Lens.Family2.LensLike' f s a +maybe'sourceFile = Data.ProtoLens.Field.field @"maybe'sourceFile" +maybe'start :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'start" a) => + Lens.Family2.LensLike' f s a +maybe'start = Data.ProtoLens.Field.field @"maybe'start" +maybe'stringValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'stringValue" a) => + Lens.Family2.LensLike' f s a +maybe'stringValue = Data.ProtoLens.Field.field @"maybe'stringValue" +maybe'swiftPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'swiftPrefix" a) => + Lens.Family2.LensLike' f s a +maybe'swiftPrefix = Data.ProtoLens.Field.field @"maybe'swiftPrefix" +maybe'syntax :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'syntax" a) => + Lens.Family2.LensLike' f s a +maybe'syntax = Data.ProtoLens.Field.field @"maybe'syntax" +maybe'trailingComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'trailingComments" a) => + Lens.Family2.LensLike' f s a +maybe'trailingComments + = Data.ProtoLens.Field.field @"maybe'trailingComments" +maybe'type' :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'type'" a) => + Lens.Family2.LensLike' f s a +maybe'type' = Data.ProtoLens.Field.field @"maybe'type'" +maybe'typeName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'typeName" a) => + Lens.Family2.LensLike' f s a +maybe'typeName = Data.ProtoLens.Field.field @"maybe'typeName" +maybe'unverifiedLazy :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'unverifiedLazy" a) => + Lens.Family2.LensLike' f s a +maybe'unverifiedLazy + = Data.ProtoLens.Field.field @"maybe'unverifiedLazy" +maybe'utf8Validation :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'utf8Validation" a) => + Lens.Family2.LensLike' f s a +maybe'utf8Validation + = Data.ProtoLens.Field.field @"maybe'utf8Validation" +maybe'value :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'value" a) => + Lens.Family2.LensLike' f s a +maybe'value = Data.ProtoLens.Field.field @"maybe'value" +maybe'verification :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'verification" a) => + Lens.Family2.LensLike' f s a +maybe'verification + = Data.ProtoLens.Field.field @"maybe'verification" +maybe'weak :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'weak" a) => + Lens.Family2.LensLike' f s a +maybe'weak = Data.ProtoLens.Field.field @"maybe'weak" +messageEncoding :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "messageEncoding" a) => + Lens.Family2.LensLike' f s a +messageEncoding = Data.ProtoLens.Field.field @"messageEncoding" +messageSetWireFormat :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "messageSetWireFormat" a) => + Lens.Family2.LensLike' f s a +messageSetWireFormat + = Data.ProtoLens.Field.field @"messageSetWireFormat" +messageType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "messageType" a) => + Lens.Family2.LensLike' f s a +messageType = Data.ProtoLens.Field.field @"messageType" +method :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "method" a) => + Lens.Family2.LensLike' f s a +method = Data.ProtoLens.Field.field @"method" +minimumEdition :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "minimumEdition" a) => + Lens.Family2.LensLike' f s a +minimumEdition = Data.ProtoLens.Field.field @"minimumEdition" +name :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "name" a) => + Lens.Family2.LensLike' f s a +name = Data.ProtoLens.Field.field @"name" +namePart :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "namePart" a) => + Lens.Family2.LensLike' f s a +namePart = Data.ProtoLens.Field.field @"namePart" +negativeIntValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "negativeIntValue" a) => + Lens.Family2.LensLike' f s a +negativeIntValue = Data.ProtoLens.Field.field @"negativeIntValue" +nestedType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "nestedType" a) => + Lens.Family2.LensLike' f s a +nestedType = Data.ProtoLens.Field.field @"nestedType" +noStandardDescriptorAccessor :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "noStandardDescriptorAccessor" a) => + Lens.Family2.LensLike' f s a +noStandardDescriptorAccessor + = Data.ProtoLens.Field.field @"noStandardDescriptorAccessor" +number :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "number" a) => + Lens.Family2.LensLike' f s a +number = Data.ProtoLens.Field.field @"number" +objcClassPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "objcClassPrefix" a) => + Lens.Family2.LensLike' f s a +objcClassPrefix = Data.ProtoLens.Field.field @"objcClassPrefix" +oneofDecl :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "oneofDecl" a) => + Lens.Family2.LensLike' f s a +oneofDecl = Data.ProtoLens.Field.field @"oneofDecl" +oneofIndex :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "oneofIndex" a) => + Lens.Family2.LensLike' f s a +oneofIndex = Data.ProtoLens.Field.field @"oneofIndex" +optimizeFor :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "optimizeFor" a) => + Lens.Family2.LensLike' f s a +optimizeFor = Data.ProtoLens.Field.field @"optimizeFor" +options :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "options" a) => + Lens.Family2.LensLike' f s a +options = Data.ProtoLens.Field.field @"options" +outputType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "outputType" a) => + Lens.Family2.LensLike' f s a +outputType = Data.ProtoLens.Field.field @"outputType" +overridableFeatures :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "overridableFeatures" a) => + Lens.Family2.LensLike' f s a +overridableFeatures + = Data.ProtoLens.Field.field @"overridableFeatures" +package :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "package" a) => + Lens.Family2.LensLike' f s a +package = Data.ProtoLens.Field.field @"package" +packed :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "packed" a) => + Lens.Family2.LensLike' f s a +packed = Data.ProtoLens.Field.field @"packed" +path :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "path" a) => + Lens.Family2.LensLike' f s a +path = Data.ProtoLens.Field.field @"path" +phpClassPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "phpClassPrefix" a) => + Lens.Family2.LensLike' f s a +phpClassPrefix = Data.ProtoLens.Field.field @"phpClassPrefix" +phpMetadataNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "phpMetadataNamespace" a) => + Lens.Family2.LensLike' f s a +phpMetadataNamespace + = Data.ProtoLens.Field.field @"phpMetadataNamespace" +phpNamespace :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "phpNamespace" a) => + Lens.Family2.LensLike' f s a +phpNamespace = Data.ProtoLens.Field.field @"phpNamespace" +positiveIntValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "positiveIntValue" a) => + Lens.Family2.LensLike' f s a +positiveIntValue = Data.ProtoLens.Field.field @"positiveIntValue" +proto3Optional :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "proto3Optional" a) => + Lens.Family2.LensLike' f s a +proto3Optional = Data.ProtoLens.Field.field @"proto3Optional" +publicDependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "publicDependency" a) => + Lens.Family2.LensLike' f s a +publicDependency = Data.ProtoLens.Field.field @"publicDependency" +pyGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "pyGenericServices" a) => + Lens.Family2.LensLike' f s a +pyGenericServices = Data.ProtoLens.Field.field @"pyGenericServices" +repeated :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "repeated" a) => + Lens.Family2.LensLike' f s a +repeated = Data.ProtoLens.Field.field @"repeated" +repeatedFieldEncoding :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "repeatedFieldEncoding" a) => + Lens.Family2.LensLike' f s a +repeatedFieldEncoding + = Data.ProtoLens.Field.field @"repeatedFieldEncoding" +reserved :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "reserved" a) => + Lens.Family2.LensLike' f s a +reserved = Data.ProtoLens.Field.field @"reserved" +reservedName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "reservedName" a) => + Lens.Family2.LensLike' f s a +reservedName = Data.ProtoLens.Field.field @"reservedName" +reservedRange :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "reservedRange" a) => + Lens.Family2.LensLike' f s a +reservedRange = Data.ProtoLens.Field.field @"reservedRange" +retention :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "retention" a) => + Lens.Family2.LensLike' f s a +retention = Data.ProtoLens.Field.field @"retention" +rubyPackage :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "rubyPackage" a) => + Lens.Family2.LensLike' f s a +rubyPackage = Data.ProtoLens.Field.field @"rubyPackage" +semantic :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "semantic" a) => + Lens.Family2.LensLike' f s a +semantic = Data.ProtoLens.Field.field @"semantic" +serverStreaming :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "serverStreaming" a) => + Lens.Family2.LensLike' f s a +serverStreaming = Data.ProtoLens.Field.field @"serverStreaming" +service :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "service" a) => + Lens.Family2.LensLike' f s a +service = Data.ProtoLens.Field.field @"service" +sourceCodeInfo :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "sourceCodeInfo" a) => + Lens.Family2.LensLike' f s a +sourceCodeInfo = Data.ProtoLens.Field.field @"sourceCodeInfo" +sourceFile :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "sourceFile" a) => + Lens.Family2.LensLike' f s a +sourceFile = Data.ProtoLens.Field.field @"sourceFile" +span :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "span" a) => + Lens.Family2.LensLike' f s a +span = Data.ProtoLens.Field.field @"span" +start :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "start" a) => + Lens.Family2.LensLike' f s a +start = Data.ProtoLens.Field.field @"start" +stringValue :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "stringValue" a) => + Lens.Family2.LensLike' f s a +stringValue = Data.ProtoLens.Field.field @"stringValue" +swiftPrefix :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "swiftPrefix" a) => + Lens.Family2.LensLike' f s a +swiftPrefix = Data.ProtoLens.Field.field @"swiftPrefix" +syntax :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "syntax" a) => + Lens.Family2.LensLike' f s a +syntax = Data.ProtoLens.Field.field @"syntax" +targets :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "targets" a) => + Lens.Family2.LensLike' f s a +targets = Data.ProtoLens.Field.field @"targets" +trailingComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "trailingComments" a) => + Lens.Family2.LensLike' f s a +trailingComments = Data.ProtoLens.Field.field @"trailingComments" +type' :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "type'" a) => + Lens.Family2.LensLike' f s a +type' = Data.ProtoLens.Field.field @"type'" +typeName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "typeName" a) => + Lens.Family2.LensLike' f s a +typeName = Data.ProtoLens.Field.field @"typeName" +uninterpretedOption :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "uninterpretedOption" a) => + Lens.Family2.LensLike' f s a +uninterpretedOption + = Data.ProtoLens.Field.field @"uninterpretedOption" +unverifiedLazy :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "unverifiedLazy" a) => + Lens.Family2.LensLike' f s a +unverifiedLazy = Data.ProtoLens.Field.field @"unverifiedLazy" +utf8Validation :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "utf8Validation" a) => + Lens.Family2.LensLike' f s a +utf8Validation = Data.ProtoLens.Field.field @"utf8Validation" +value :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "value" a) => + Lens.Family2.LensLike' f s a +value = Data.ProtoLens.Field.field @"value" +vec'annotation :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'annotation" a) => + Lens.Family2.LensLike' f s a +vec'annotation = Data.ProtoLens.Field.field @"vec'annotation" +vec'declaration :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'declaration" a) => + Lens.Family2.LensLike' f s a +vec'declaration = Data.ProtoLens.Field.field @"vec'declaration" +vec'defaults :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'defaults" a) => + Lens.Family2.LensLike' f s a +vec'defaults = Data.ProtoLens.Field.field @"vec'defaults" +vec'dependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'dependency" a) => + Lens.Family2.LensLike' f s a +vec'dependency = Data.ProtoLens.Field.field @"vec'dependency" +vec'editionDefaults :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'editionDefaults" a) => + Lens.Family2.LensLike' f s a +vec'editionDefaults + = Data.ProtoLens.Field.field @"vec'editionDefaults" +vec'enumType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'enumType" a) => + Lens.Family2.LensLike' f s a +vec'enumType = Data.ProtoLens.Field.field @"vec'enumType" +vec'extension :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'extension" a) => + Lens.Family2.LensLike' f s a +vec'extension = Data.ProtoLens.Field.field @"vec'extension" +vec'extensionRange :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'extensionRange" a) => + Lens.Family2.LensLike' f s a +vec'extensionRange + = Data.ProtoLens.Field.field @"vec'extensionRange" +vec'field :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'field" a) => + Lens.Family2.LensLike' f s a +vec'field = Data.ProtoLens.Field.field @"vec'field" +vec'file :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'file" a) => + Lens.Family2.LensLike' f s a +vec'file = Data.ProtoLens.Field.field @"vec'file" +vec'leadingDetachedComments :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'leadingDetachedComments" a) => + Lens.Family2.LensLike' f s a +vec'leadingDetachedComments + = Data.ProtoLens.Field.field @"vec'leadingDetachedComments" +vec'location :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'location" a) => + Lens.Family2.LensLike' f s a +vec'location = Data.ProtoLens.Field.field @"vec'location" +vec'messageType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'messageType" a) => + Lens.Family2.LensLike' f s a +vec'messageType = Data.ProtoLens.Field.field @"vec'messageType" +vec'method :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'method" a) => + Lens.Family2.LensLike' f s a +vec'method = Data.ProtoLens.Field.field @"vec'method" +vec'name :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'name" a) => + Lens.Family2.LensLike' f s a +vec'name = Data.ProtoLens.Field.field @"vec'name" +vec'nestedType :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'nestedType" a) => + Lens.Family2.LensLike' f s a +vec'nestedType = Data.ProtoLens.Field.field @"vec'nestedType" +vec'oneofDecl :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'oneofDecl" a) => + Lens.Family2.LensLike' f s a +vec'oneofDecl = Data.ProtoLens.Field.field @"vec'oneofDecl" +vec'path :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'path" a) => + Lens.Family2.LensLike' f s a +vec'path = Data.ProtoLens.Field.field @"vec'path" +vec'publicDependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'publicDependency" a) => + Lens.Family2.LensLike' f s a +vec'publicDependency + = Data.ProtoLens.Field.field @"vec'publicDependency" +vec'reservedName :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'reservedName" a) => + Lens.Family2.LensLike' f s a +vec'reservedName = Data.ProtoLens.Field.field @"vec'reservedName" +vec'reservedRange :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'reservedRange" a) => + Lens.Family2.LensLike' f s a +vec'reservedRange = Data.ProtoLens.Field.field @"vec'reservedRange" +vec'service :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'service" a) => + Lens.Family2.LensLike' f s a +vec'service = Data.ProtoLens.Field.field @"vec'service" +vec'span :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'span" a) => + Lens.Family2.LensLike' f s a +vec'span = Data.ProtoLens.Field.field @"vec'span" +vec'targets :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'targets" a) => + Lens.Family2.LensLike' f s a +vec'targets = Data.ProtoLens.Field.field @"vec'targets" +vec'uninterpretedOption :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'uninterpretedOption" a) => + Lens.Family2.LensLike' f s a +vec'uninterpretedOption + = Data.ProtoLens.Field.field @"vec'uninterpretedOption" +vec'value :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'value" a) => + Lens.Family2.LensLike' f s a +vec'value = Data.ProtoLens.Field.field @"vec'value" +vec'weakDependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "vec'weakDependency" a) => + Lens.Family2.LensLike' f s a +vec'weakDependency + = Data.ProtoLens.Field.field @"vec'weakDependency" +verification :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "verification" a) => + Lens.Family2.LensLike' f s a +verification = Data.ProtoLens.Field.field @"verification" +weak :: + forall f s a. + (Prelude.Functor f, Data.ProtoLens.Field.HasField s "weak" a) => + Lens.Family2.LensLike' f s a +weak = Data.ProtoLens.Field.field @"weak" +weakDependency :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "weakDependency" a) => + Lens.Family2.LensLike' f s a +weakDependency = Data.ProtoLens.Field.field @"weakDependency" diff --git a/app/protoc-gen-haskell.hs b/app/protoc-gen-haskell.hs new file mode 100644 --- /dev/null +++ b/app/protoc-gen-haskell.hs @@ -0,0 +1,117 @@ +-- Copyright 2016 Google Inc. All Rights Reserved. +-- +-- Use of this source code is governed by a BSD-style +-- license that can be found in the LICENSE file or at +-- https://developers.google.com/open-source/licenses/bsd + +{-# LANGUAGE CPP #-} +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE OverloadedStrings #-} +module Main where + +import Control.Monad.IO.Class (liftIO) +import qualified Data.ByteString as B +import Data.Map.Strict ((!)) +#if !MIN_VERSION_base(4,11,0) +import Data.Semigroup ((<>)) +#endif +import qualified Data.Set as Set +import qualified Data.Text as T +import Data.Text (Text, pack) +import Data.Bits +import Data.ProtoLens (defMessage, decodeMessage, encodeMessage) +-- Force the use of the Reflected API when decoding DescriptorProto +-- so that we can run the test suite against the Generated API. +-- TODO: switch back to Data.ProtoLens.Encoding once the Generated encoding is +-- good enough. +import Lens.Family2 +import Proto.Google.Protobuf.Compiler.Plugin + ( CodeGeneratorRequest + , CodeGeneratorResponse + , CodeGeneratorResponse'Feature(..) + ) +import Proto.Google.Protobuf.Descriptor (FileDescriptorProto, Edition(..)) +import System.Environment (getProgName) +import System.Exit (exitWith, ExitCode(..)) +import System.IO as IO + +import Data.ProtoLens.Compiler.Generate.Commented (getModuleName) +import Data.ProtoLens.Compiler.Generate +import Data.ProtoLens.Compiler.Plugin + +#if MIN_VERSION_ghc(9,0,0) +import GHC.Driver.Session (DynFlags, getDynFlags) +#else +import DynFlags (DynFlags, getDynFlags) +#endif +import GHC (runGhc) +import GHC.Paths (libdir) +import GHC.SourceGen.Pretty (showPpr) + +main :: IO () +main = do + contents <- B.getContents + progName <- getProgName + case decodeMessage contents of + Left e -> IO.hPutStrLn stderr e >> exitWith (ExitFailure 1) + Right x -> runGhc (Just libdir) $ do + dflags <- getDynFlags + liftIO $ B.putStr $ encodeMessage $ + makeResponse dflags progName x + +makeResponse :: DynFlags -> String -> CodeGeneratorRequest -> CodeGeneratorResponse +makeResponse dflags prog request = let + outputFiles = generateFiles dflags header + (request ^. #protoFile) + (request ^. #fileToGenerate) + header :: FileDescriptorProto -> Text + header f = "{- This file was auto-generated from " + <> (f ^. #name) + <> " by the " <> pack prog <> " program. -}\n" + features = [ CodeGeneratorResponse'FEATURE_PROTO3_OPTIONAL + , CodeGeneratorResponse'FEATURE_SUPPORTS_EDITIONS + ] + preamble = defMessage + & #supportedFeatures .~ + foldl (.|.) zeroBits (fmap (toEnum . fromEnum) features) + -- Do not process actual Protobuf Editions files yet. + & #minimumEdition .~ fromIntegral (fromEnum EDITION_PROTO2) + & #maximumEdition .~ fromIntegral (fromEnum EDITION_2024) + in case outputFiles of + Right fs -> preamble & #file .~ + [ defMessage + & #name .~ outputName + & #content .~ outputContent + | (outputName, outputContent) <- fs + ] + Left e -> preamble & #error .~ e + +generateFiles :: DynFlags -> (FileDescriptorProto -> Text) + -> [FileDescriptorProto] -> [ProtoFileName] + -> Either Text [(Text, Text)] +generateFiles dflags header files toGenerate = do + filesByName <- analyzeProtoFiles files + + let modulesToBuild f = + generateModule (haskellModule f) (descriptor f) imports + (publicImports f) + (definitions f) + (collectEnvFromDeps deps filesByName) + (services f) + where + deps = descriptor f ^. #dependency + imports = Set.toAscList $ Set.fromList + $ map (haskellModule . (filesByName !)) deps + + + -- The contents of the generated Haskell file for a given .proto file. + return [ ( moduleFilePath $ pack $ showPpr dflags (getModuleName modul) + , header (descriptor f) <> pack (showPpr dflags modul) + ) + | fileName <- toGenerate + , let f = filesByName ! fileName + , modul <- modulesToBuild f + ] + +moduleFilePath :: Text -> Text +moduleFilePath n = T.replace "." "/" n <> ".hs" diff --git a/proto-lens-protoc.cabal b/proto-lens-protoc.cabal --- a/proto-lens-protoc.cabal +++ b/proto-lens-protoc.cabal @@ -1,90 +1,73 @@ -name: proto-lens-protoc -version: 0.1.0.5 -synopsis: Protocol buffer compiler for the proto-lens library. -description: - Turn protocol buffer files (.proto) into Haskell files (.hs) which - can be used with the proto-lens package. +cabal-version: 1.12 - The library component of this package contains compiler code (namely - Data.ProtoLens.Compiler.*) that is not guaranteed to have stable APIs. -license: BSD3 -license-file: LICENSE -author: Judah Jacobson -maintainer: judahjacobson@google.com -copyright: Google Inc. -category: Data -build-type: Simple -cabal-version: >=1.21 +-- This file has been generated from package.yaml by hpack version 0.39.1. +-- +-- see: https://github.com/sol/hpack --- Work around stack bug, since we don't want to build the library --- during bootstrapping: --- https://github.com/commercialhaskell/stack/issues/1406 -flag only-executable - Description: Only build the executable. Used for bootstrapping. - Default: False +name: proto-lens-protoc +version: 0.9.0.1 +synopsis: Protocol buffer compiler for the proto-lens library. +description: Turn protocol buffer files (.proto) into Haskell files (.hs) which can be used with the proto-lens package. + The library component of this package contains compiler code (namely Data.ProtoLens.Compiler.*) is not guaranteed to have stable APIs.' +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 +extra-source-files: + Changelog.md +source-repository head + type: git + location: https://github.com/google/proto-lens + subdir: proto-lens-protoc + library - if flag(only-executable) { - buildable: False - } else { - exposed-modules: - Data.ProtoLens.Compiler.Combinators - Data.ProtoLens.Compiler.Definitions - Data.ProtoLens.Compiler.Generate - Data.ProtoLens.Compiler.Plugin - Data.ProtoLens.Setup - default-language: Haskell2010 - hs-source-dirs: src - build-depends: - Cabal >= 1.22 && < 1.25 - , base >= 4.8 && < 4.10 - , bytestring == 0.10.* - , containers == 0.5.* - , data-default-class >= 0.0 && < 0.2 - , directory == 1.2.* - , filepath == 1.4.* - , haskell-src-exts == 1.17.* - , lens-family == 1.2.* - , process >= 1.2 && < 1.5 - , proto-lens == 0.1.0.5 - , proto-lens-descriptors == 0.1.0.5 - , text == 1.2.* - reexported-modules: - -- Modules that are needed by the generated Haskell files. - -- For forwards compatibility, reexport them as new module names so that - -- other packages don't accidentally write non-generated code that - -- relies on these modules being reexported by proto-lens-protoc. - Data.ByteString as Data.ProtoLens.Reexport.Data.ByteString - , Data.Default.Class as Data.ProtoLens.Reexport.Data.Default.Class - , Data.Map as Data.ProtoLens.Reexport.Data.Map - , Data.ProtoLens as Data.ProtoLens.Reexport.Data.ProtoLens - , Data.ProtoLens.Message.Enum as Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum - , Data.Text as Data.ProtoLens.Reexport.Data.Text - , Lens.Family2 as Data.ProtoLens.Reexport.Lens.Family2 - , Lens.Family2.Unchecked as Data.ProtoLens.Reexport.Lens.Family2.Unchecked - } + exposed-modules: + Data.ProtoLens.Compiler.ModuleName + other-modules: + Paths_proto_lens_protoc + hs-source-dirs: + src + build-depends: + base >=4.10 && <4.23 + , filepath >=1.4 && <1.6 + default-language: Haskell2010 executable proto-lens-protoc - main-is: protoc-gen-haskell.hs - - build-depends: - base >= 4.8 && < 4.10 - , bytestring == 0.10.* - , containers == 0.5.* - , data-default-class >= 0.0 && < 0.2 - , filepath == 1.4.* - , haskell-src-exts == 1.17.* - , lens-family == 1.2.* - -- Specify an exact version of `proto-lens`, since it's tied closely - -- to the generated code. - , proto-lens == 0.1.0.5 - , proto-lens-descriptors == 0.1.0.5 - , text == 1.2.* - hs-source-dirs: src + main-is: protoc-gen-haskell.hs other-modules: - Data.ProtoLens.Compiler.Combinators Data.ProtoLens.Compiler.Definitions + Data.ProtoLens.Compiler.Editions.Defaults + Data.ProtoLens.Compiler.Editions.Features Data.ProtoLens.Compiler.Generate + Data.ProtoLens.Compiler.Generate.Commented + Data.ProtoLens.Compiler.Generate.Encoding + Data.ProtoLens.Compiler.Generate.Field Data.ProtoLens.Compiler.Plugin - - default-language: Haskell2010 + Proto.Google.Protobuf.Compiler.Plugin + Proto.Google.Protobuf.Compiler.Plugin_Fields + Proto.Google.Protobuf.Descriptor + Proto.Google.Protobuf.Descriptor_Fields + Paths_proto_lens_protoc + hs-source-dirs: + app + build-depends: + base >=4.10 && <4.23 + , bytestring >=0.10 && <0.14 + , containers >=0.5 && <0.9 + , filepath >=1.4 && <1.6 + , ghc >=8.2 && <9.15 + , ghc-paths ==0.1.* + , ghc-source-gen ==0.4.* + , lens-family >=1.2 && <2.2 + , pretty ==1.1.* + , proto-lens ==0.7.* + , proto-lens-protoc + , proto-lens-runtime ==0.7.* + , text >=1.2 && <2.2 + default-language: Haskell2010 diff --git a/src/Data/ProtoLens/Compiler/Combinators.hs b/src/Data/ProtoLens/Compiler/Combinators.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Combinators.hs +++ /dev/null @@ -1,98 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd - -{-# OPTIONS_GHC -fno-warn-orphans #-} --- | Some utility functions, classes and instances for nicer code generation --- with haskell-src-exts. --- --- In particular, we define orphan instances of IsString for various syntax --- datatypes, with some intelligence about Haskell names. For example, @"foo" --- :: Exp@ is treated as a variable and @"Foo" :: Exp@ is treated as a --- constructor. -module Data.ProtoLens.Compiler.Combinators where - -import Data.Char (isAlphaNum, isUpper) -import Data.String (IsString(..)) -import Language.Haskell.Exts.SrcLoc (noLoc) -import Language.Haskell.Exts.Syntax as Syntax - --- | Application of a Haskell type or expression to an argument. --- For example, to represent @f x y@, you can write --- --- > "f" @@ "x" @@ "y" -class App a where - (@@) :: a -> a -> a - infixl 2 @@ - -instance App Type where - (@@) = TyApp - -instance App Exp where - (@@) = App - -instance IsString Name where - fromString s - -- TODO: better handle the case of mixed ident and symbol characters. - | all isIdentChar s = Ident s - | otherwise = Symbol s - --- | Whether this character belongs to an Ident (e.g., "foo") or a symbol --- (e.g., "<$>"). -isIdentChar :: Char -> Bool -isIdentChar c = isAlphaNum c || c `elem` "_'" - -instance IsString ModuleName where - fromString = ModuleName - -instance IsString QName where - fromString f - -- TODO: support qualified operators (e.g., "Control.Applicative.<$>") - -- Currently we ignore them due to edge-cases - -- like the composition operator "Prelude.." - | isIdentChar (last f), '.' `elem` f - -- Split "Foo.Bar.baz" into ("Foo.Bar", "baz") - , (f', '.':f'') <- span (/='.') (reverse f) - = Qual (fromString $ reverse f'') (fromString $ reverse f') - | otherwise = UnQual $ fromString f - -instance IsString Type where - fromString fs@(f:_) - | isUpper f = TyCon $ fromString fs - fromString fs = TyVar $ fromString fs - -instance IsString Exp where - fromString fs@(f:_) - | isUpper f = Con $ fromString fs - fromString fs = Var $ fromString fs - -instance IsString Pat where - fromString = PVar . fromString - -instance IsString TyVarBind where - fromString = UnkindedVar . fromString - - --- Helper functions for literal numbers, since haskell-src-exts doesn't --- put parentheses around negative numbers automatically. - -litInt :: Integer -> Exp -litInt n - | n >= 0 = Lit $ Int n - | otherwise = NegApp $ Lit $ Int $ negate n - -litFrac :: Rational -> Exp -litFrac x - | x >= 0 = Lit $ Frac x - | otherwise = NegApp $ Lit $ Frac $ negate x - -pLitInt :: Integer -> Pat -pLitInt n - | n >= 0 = PLit Signless $ Int n - | otherwise = PLit Negative $ Int $ negate n - --- | A simple clause of a function binding. -match :: Name -> [Pat] -> Exp -> Match -match n ps e = Match noLoc n ps Nothing (UnGuardedRhs e) Nothing diff --git a/src/Data/ProtoLens/Compiler/Definitions.hs b/src/Data/ProtoLens/Compiler/Definitions.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Definitions.hs +++ /dev/null @@ -1,261 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd - --- | This module takes care of collecting all the definitions in a .proto file --- and assigning Haskell names to all of the defined things (messages, enums --- and field names). -{-# LANGUAGE DeriveFunctor, OverloadedStrings #-} -module Data.ProtoLens.Compiler.Definitions - ( Env - , Definition(..) - , MessageInfo(..) - , FieldInfo(..) - , EnumInfo(..) - , EnumValueInfo(..) - , qualifyEnv - , unqualifyEnv - , collectDefinitions - , definedFieldType - ) where - -import Data.Char (toUpper) -import Data.Int (Int32) -import Data.List (mapAccumL) -import qualified Data.Map as Map -import Data.Maybe (fromMaybe) -import Data.Monoid -import qualified Data.Set as Set -import Data.Text (Text, cons, splitOn, toLower, uncons, unpack) -import qualified Data.Text as T -import Language.Haskell.Exts.Syntax (Name(..), QName(..), ModuleName(..)) -import Lens.Family2 ((^.)) -import Proto.Google.Protobuf.Descriptor - ( DescriptorProto - , EnumDescriptorProto - , EnumValueDescriptorProto - , FieldDescriptorProto - , FileDescriptorProto - , enumType - , field - , messageType - , name - , nestedType - , number - , package - , typeName - , value - ) - --- | 'Env' contains a mapping of proto names (as specified in the .proto file) --- to Haskell names. The keys are fully-qualified names, for example, --- ".package.Message.Submessage". (The protocol_compiler tool emits all --- message field types in this form, even if they refer to local definitions.) --- --- The type 'n' can be either a 'Name' (when talking about definitions within --- the current file) or a (qualified) 'QName' (when talking about definitions --- either from this or another file). -type Env n = Map.Map Text (Definition n) - -data Definition n = Message (MessageInfo n) | Enum (EnumInfo n) - deriving Functor - --- | All the information needed to define or use a proto message type. -data MessageInfo n = MessageInfo - { messageName :: n -- ^ Haskell type name - , messageDescriptor :: DescriptorProto - , messageFields :: [FieldInfo] - -- ^ The Haskell names for each field. - -- This list corresponds 1-1 with "field" in messageDescriptor. - } deriving Functor - --- | Information about a single field of a proto message. -data FieldInfo = FieldInfo - { overloadedField :: String - -- ^ The Haskell overloaded name of this field; may be shared between two - -- different message data types. - , recordFieldName :: Name - -- ^ The Haskell name of this internal record field. Unique within each - -- module. - , fieldDescriptor :: FieldDescriptorProto - } - --- | All the information needed to define or use a proto enum type. -data EnumInfo n = EnumInfo - { enumName :: n - , enumDescriptor :: EnumDescriptorProto - , enumValues :: [EnumValueInfo n] - } deriving Functor - --- | Information about a single value case of a proto enum. -data EnumValueInfo n = EnumValueInfo - { enumValueName :: n - , enumValueDescriptor :: EnumValueDescriptorProto - , enumAliasOf :: Maybe Name - -- ^ If 'Nothing', we turn value into a normal constructor of the enum. - -- If @'Just' n@, we're treating it as an alias of the constructor @n@ - -- (a PatternSynonym in Haskell). This mirrors the behavior of the - -- Java API. - } deriving Functor - -mapEnv :: (n -> n') -> Env n -> Env n' -mapEnv f = fmap $ fmap f - --- Lift a set of local definitions into references to a specific module. -qualifyEnv :: ModuleName -> Env Name -> Env QName -qualifyEnv m = mapEnv (Qual m) - --- Lift a set of local definitions into references to the current module. -unqualifyEnv :: Env Name -> Env QName -unqualifyEnv = mapEnv UnQual - --- | Look up the type definition for a given field. -definedFieldType :: FieldDescriptorProto -> Env QName -> Definition QName -definedFieldType fd env = fromMaybe err $ Map.lookup (fd ^. typeName) env - where - err = error $ "definedFieldType: Field type " ++ unpack (fd ^. typeName) - ++ " not found in environment." - --- | Collect all the definitions in the given file (including definitions --- nested in other messages), and assign Haskell names to them. -collectDefinitions :: FileDescriptorProto -> Env Name -collectDefinitions fd = let - protoPrefix = case fd ^. package of - "" -> "." - p -> "." <> p <> "." - hsPrefix = "" - in Map.fromList $ messageAndEnumDefs protoPrefix hsPrefix - (fd ^. messageType) (fd ^. enumType) - -messageAndEnumDefs :: Text -> String -> [DescriptorProto] - -> [EnumDescriptorProto] -> [(Text, Definition Name)] -messageAndEnumDefs protoPrefix hsPrefix messages enums - = concatMap (messageDefs protoPrefix hsPrefix) messages - ++ map (enumDef protoPrefix hsPrefix) enums - --- | Generate the definitions for a message and its nested types (if any). -messageDefs :: Text -> String -> DescriptorProto - -> [(Text, Definition Name)] -messageDefs protoPrefix hsPrefix d - = thisDef : subDefs - where - protoName = d ^. name - hsName = unpack $ capitalize $ d ^. name - thisDef = (protoPrefix <> protoName - , Message MessageInfo - { messageName = Ident $ hsPrefix ++ hsName - , messageDescriptor = d - , messageFields = - [ FieldInfo - { overloadedField = n - , recordFieldName = Ident $ "_" ++ hsPrefix' ++ n - , fieldDescriptor = f - } - | f <- d ^. field - , let n = fieldName (f ^. name) - ] - }) - subDefs = messageAndEnumDefs protoPrefix' hsPrefix' - (d ^. nestedType) (d ^. enumType) - protoPrefix' = protoPrefix <> protoName <> "." - hsPrefix' = hsPrefix ++ hsName ++ "'" - --- | Get the name in Haskell of a proto field, taking care of camel casing and --- clashes with language keywords. -fieldName :: Text -> String -fieldName = unpack . disambiguate . camelCase - where - disambiguate s - -- TODO: use a more comprehensive blacklist of Haskell keywords. - | s `Set.member` reservedKeywords = s <> "'" - | otherwise = s - camelCase s - -- Preserve any initial underlines (e.g., "_foo_bar" -> "_fooBar"). - | (underlines, rest) <- T.span (== '_') s - = case splitOn "_" rest of - -- splitOn always returns a list with at least one element. - [] -> error $ "camelCase: splitOn returned empty list: " - ++ show rest - [""] -> error "camelCase: name consists only of underscores" - s':ss -> T.concat $ underlines : toLower s' : map capitalize ss - --- | A list of reserved keywords that aren't valid as variable names. -reservedKeywords :: Set.Set Text -reservedKeywords = Set.fromList $ - -- Haskell2010 keywords: - -- https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4 - -- We don't include keywords that are allowed to be variable names, - -- in particular: "as", "forall", and "hiding". - [ "case" - , "class" - , "data" - , "default" - , "deriving" - , "do" - , "else" - , "foreign" - , "if" - , "import" - , "in" - , "infix" - , "infixl" - , "infixr" - , "instance" - , "let" - , "module" - , "newtype" - , "of" - , "then" - , "type" - , "where" - ] - ++ -- Nonstandard extensions - [ "mdo" -- RecursiveDo - , "rec" -- Arrows, RecursiveDo - , "pattern" -- PatternSynonyms - , "proc" -- Arrows - ] - --- | Generate the definition for an enum type. -enumDef :: Text -> String -> EnumDescriptorProto - -> (Text, Definition Name) -enumDef protoPrefix hsPrefix d = let - mkText n = protoPrefix <> n - mkHsName n = Ident $ hsPrefix ++ unpack n - in (mkText (d ^. name) - , Enum EnumInfo - { enumName = mkHsName (d ^. name) - , enumDescriptor = d - , enumValues = collectEnumValues mkHsName $ d ^. value - }) - --- | Generate the definitions for each enum value. In particular, decide --- whether it's a true constructor or a PatternSynonym to another --- constructor. --- --- Like Java, we treat the first case of each numeric value as the "real" --- constructor, and subsequent cases as synonyms. -collectEnumValues :: (Text -> Name) -> [EnumValueDescriptorProto] - -> [EnumValueInfo Name] -collectEnumValues mkHsName = snd . mapAccumL helper Map.empty - where - helper :: Map.Map Int32 Name -> EnumValueDescriptorProto - -> (Map.Map Int32 Name, EnumValueInfo Name) - helper seenNames v - | Just n' <- Map.lookup k seenNames = (seenNames, mkValue (Just n')) - | otherwise = (Map.insert k hsName seenNames, mkValue Nothing) - where - mkValue = EnumValueInfo hsName v - hsName = mkHsName n - n = v ^. name - k = v ^. number - --- Haskell types must start with an uppercase letter, so we capitalize message --- and enum names. --- Name collisions will show up as build errors in the generated haskell file. -capitalize :: Text -> Text -capitalize s - | Just (c, s') <- uncons s = cons (toUpper c) s' - | otherwise = s diff --git a/src/Data/ProtoLens/Compiler/Generate.hs b/src/Data/ProtoLens/Compiler/Generate.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Generate.hs +++ /dev/null @@ -1,697 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd - --- | This module builds the actual, generated Haskell file --- for a given input .proto file. -{-# LANGUAGE OverloadedStrings #-} -module Data.ProtoLens.Compiler.Generate( - generateModule, - fileSyntaxType, - ModifyImports, - reexported, - ) where - - -import Control.Applicative ((<$>)) -import Control.Arrow (second) -import qualified Data.Foldable as F -import qualified Data.List as List -import qualified Data.Map as Map -import Data.Maybe (isNothing) -import Data.Ord (comparing) -import qualified Data.Set as Set -import Data.String (fromString) -import Data.Text (unpack) -import qualified Data.Text as T -import Data.Tuple (swap) -import Language.Haskell.Exts.Syntax as Syntax -import Language.Haskell.Exts.SrcLoc (noLoc) -import Lens.Family2 ((^.)) -import Proto.Google.Protobuf.Descriptor - ( EnumValueDescriptorProto - , FieldDescriptorProto - , FieldDescriptorProto'Label(..) - , FieldDescriptorProto'Type(..) - , FileDescriptorProto - , FieldOptions - , defaultValue - , label - , mapEntry - , maybe'oneofIndex - , maybe'packed - , name - , number - , options - , syntax - , type' - , typeName - ) - -import Data.ProtoLens.Compiler.Combinators -import Data.ProtoLens.Compiler.Definitions - -data SyntaxType = Proto2 | Proto3 - deriving Eq - -fileSyntaxType :: FileDescriptorProto -> SyntaxType -fileSyntaxType f = case f ^. syntax of - "proto2" -> Proto2 - "proto3" -> Proto3 - "" -> Proto2 -- The proto compiler doesn't set syntax for proto2 files. - s -> error $ "Unknown syntax type " ++ show s - --- Whether to import the "Reexport" modules or the originals; --- e.g., Data.ProtoLens.Reexport.Data.Map vs Data.Map. -data UseReexport = UseReexport | UseOriginal - deriving (Eq, Read) - --- | Generate a Haskell module for the given input file(s). --- input contains all defined names, incl. those in this module -generateModule :: ModuleName - -> [ModuleName] -- ^ The imported modules - -> SyntaxType - -> ModifyImports - -> Env Name -- ^ Definitions in this file - -> Env QName -- ^ Definitions in the imported modules - -> Module -generateModule modName imports syntaxType modifyImport definitions importedEnv - = Module noLoc modName - [ LanguagePragma noLoc $ map Ident - ["ScopedTypeVariables", "DataKinds", "TypeFamilies", - "MultiParamTypeClasses", "FlexibleContexts", "FlexibleInstances", - "PatternSynonyms"] - -- Allow unused imports in case we don't import anything from - -- Data.Text, Data.Int, etc. - , OptionsPragma noLoc (Just GHC) "-fno-warn-unused-imports" - ] - Nothing -- no warning text - Nothing -- no explicit exports; we export everything. - -- TODO: Also export public imports, taking care not to - -- cause a name conflict between field accessors. - (map importSimple - -- Note: we import Prelude explicitly to make it qualified. - [ "Prelude", "Data.Int", "Data.Word"] - ++ map (modifyImport . importSimple) - [ "Data.ProtoLens", "Data.ProtoLens.Message.Enum" - , "Lens.Family2", "Lens.Family2.Unchecked", "Data.Default.Class" - , "Data.Text", "Data.Map" , "Data.ByteString" - ] - ++ map importSimple imports) - (concatMap generateDecls (Map.elems definitions) - ++ concatMap generateFieldDecls allFieldNames) - where - env = Map.union (unqualifyEnv definitions) importedEnv - generateDecls (Message m) = generateMessageDecls syntaxType env m - generateDecls (Enum e) = generateEnumDecls e - allFieldNames = F.toList $ Set.fromList - [ fieldSymbol i - | Message m <- Map.elems definitions - , f <- messageFields m - , i <- fieldInstances (lensInfo syntaxType env f) - ] - -importSimple :: ModuleName -> ImportDecl -importSimple m = ImportDecl - { importLoc = noLoc - , importModule = m - -- Import qualified to avoid clashes with names defined in this module. - , importQualified = True - , importSrc = False - , importSafe = False - , importPkg = Nothing - , importAs = Nothing - , importSpecs = Nothing - } - -type ModifyImports = ImportDecl -> ImportDecl - -reexported :: ModifyImports -reexported imp@ImportDecl {importModule = m@(ModuleName s)} - = imp { importAs = Just m, importModule = m' } - where - m' = ModuleName $ "Data.ProtoLens.Reexport." ++ s - -generateMessageDecls :: SyntaxType -> Env QName -> MessageInfo Name -> [Decl] -generateMessageDecls syntaxType env info = - -- data Bar = Bar { - -- foo :: Baz - -- } - [ DataDecl noLoc DataType [] dataName [] - [QualConDecl noLoc [] [] $ RecDecl dataName - [([recordFieldName f], - TyBang BangedTy $ internalType (lensInfo syntaxType env f)) - | f <- fields - ] - ] - [("Prelude.Show", []), ("Prelude.Eq", [])] - ] - ++ - -- type instance Field.Field "foo" Bar = Baz - -- instance Field.HasField "foo" Bar where - -- field _ = ... - -- Note: for optional fields, this generates an instance both for "foo" and - -- for "maybe'foo" (see lensInfo below). - concat - [ [ TypeInsDecl noLoc - ("Data.ProtoLens.Field" @@ sym @@ dataType) - (fieldTypeInstance i) - , InstDecl noLoc Nothing [] [] "Data.ProtoLens.HasField" - [sym, dataType, dataType] - [InsDecl $ FunBind [match "field" [PWildCard] $ fieldAccessor i]] - ] - | f <- fields - , i <- fieldInstances (lensInfo syntaxType env f) - , let sym = TyPromoted $ PromotedString $ fieldSymbol i - ] - ++ - -- instance Data.Default.Class.Default Bar where - [ InstDecl noLoc Nothing [] [] "Data.Default.Class.Default" [dataType] - -- def = Bar { _Bar_foo = 0 } - [ InsDecl $ FunBind - [ match "def" [] - $ RecConstr (UnQual dataName) - [ FieldUpdate (UnQual $ recordFieldName f) - (hsFieldDefault syntaxType env (fieldDescriptor f)) - | f <- fields - ] - ] - ] - -- instance Message.Message Bar where - , InstDecl noLoc Nothing [] [] "Data.ProtoLens.Message" [dataType] - [ InsDecl $ FunBind - [ match "descriptor" [] $ descriptorExpr syntaxType env info] - ] - ] - where - dataType = TyCon $ UnQual dataName - MessageInfo { messageName = dataName, messageFields = fields} = info - -generateEnumDecls :: EnumInfo Name -> [Decl] -generateEnumDecls info = - [ DataDecl noLoc DataType [] dataName [] - [QualConDecl noLoc [] [] $ ConDecl n [] | n <- constructorNames] - [(c, []) | c <- ["Prelude.Show", "Prelude.Eq"]] - -- instance Data.Default.Class.Default Foo where - -- def = FirstEnumValue - , InstDecl noLoc Nothing [] [] "Data.Default.Class.Default" [dataType] - [ InsDecl $ FunBind [match "def" [] defaultCon] - ] - -- instance Data.ProtoLens.FieldDefault Foo where - -- fieldDefault = FirstEnumValue - , InstDecl noLoc Nothing [] [] "Data.ProtoLens.FieldDefault" [dataType] - [ InsDecl $ FunBind [match "fieldDefault" [] defaultCon] - ] - -- instance MessageEnum Foo where - -- maybeToEnum 1 = Just Foo1 - -- maybeToEnum 2 = Just Foo2 - -- ... - -- maybeToEnum _ = Nothing - -- showEnum Foo1 = "Foo1" - -- showEnum Foo2 = "Foo2" - -- ... - -- readEnum "Foo1" = Just Foo1 - -- readEnum "Foo2" = Just Foo2 - -- ... - -- readEnum _ = Nothing - , InstDecl noLoc Nothing [] [] "Data.ProtoLens.MessageEnum" [dataType] - [ InsDecl $ FunBind $ - [ match "maybeToEnum" [pLitInt k] - $ "Prelude.Just" @@ Con (UnQual n) - | (n, k) <- constructorNumbers - ] - ++ - [ match "maybeToEnum" [PWildCard] "Prelude.Nothing" - ] - ++ - [ match "showEnum" [PVar n] $ Lit $ Syntax.String $ T.unpack pn - | (n, pn) <- constructorProtoNames - ] - ++ - [ match "readEnum" - [PLit Signless . Syntax.String $ T.unpack pn] - $ "Prelude.Just" @@ Con (UnQual n) - | (n, pn) <- constructorProtoNames - ] - ++ - [ match "readEnum" [PWildCard] "Prelude.Nothing" - ] - ] - -- instance Enum Foo where - -- toEnum k = maybe (error ("Foo.toEnum: unknown argument for enum Foo: " - -- ++ show k)) - -- id (maybeToEnum k) - -- fromEnum Foo1 = 1 - -- fromEnum Foo2 = 2 - -- .. - -- succ FooN = error "Foo.succ: bad argument FooN." - -- succ Foo1 = Foo2 - -- succ Foo2 = Foo3 - -- .. - -- pred Foo1 = error "Foo.succ: bad argument Foo1." - -- pred Foo2 = Foo1 - -- pred Foo3 = Foo2 - -- .. - -- enumFrom = messageEnumFrom - -- enumFromTo = messageEnumFromTo - -- enumFromThen = messageEnumFromThen - -- enumFromThenTo = messageEnumFromThenTo - , InstDecl noLoc Nothing [] [] "Prelude.Enum" [dataType] - [ InsDecl $ FunBind - [ match "toEnum" ["k__"] - $ "Prelude.maybe" @@ errorMessageExpr @@ "Prelude.id" - @@ ("Data.ProtoLens.maybeToEnum" @@ "k__") - ] - , InsDecl $ FunBind - [ match "fromEnum" [PApp (UnQual c) []] $ litInt k - | (c, k) <- constructorNumbers - ] - , succDecl "succ" maxBoundName succPairs - , succDecl "pred" minBoundName $ map swap succPairs - , alias "enumFrom" "Data.ProtoLens.Message.Enum.messageEnumFrom" - , alias "enumFromTo" "Data.ProtoLens.Message.Enum.messageEnumFromTo" - , alias "enumFromThen" "Data.ProtoLens.Message.Enum.messageEnumFromThen" - , alias "enumFromThenTo" - "Data.ProtoLens.Message.Enum.messageEnumFromThenTo" - ] - -- instance Bounded Foo where - -- minBound = Foo1 - -- maxBound = FooN - , InstDecl noLoc Nothing [] [] "Prelude.Bounded" [dataType] - [ InsDecl $ FunBind - [ match "minBound" [] $ Con $ UnQual minBoundName - , match "maxBound" [] $ Con $ UnQual maxBoundName - ] - ] - ] - ++ - -- pattern FooAlias :: Foo - -- pattern FooAlias = FooConstructor - concat - [ [ PatSynSig noLoc aliasName Nothing [] [] dataType - , PatSyn noLoc (PVar aliasName) (PVar originalName) - ImplicitBidirectional - ] - | EnumValueInfo - { enumValueName = aliasName - , enumAliasOf = Just originalName - } <- enumValues info - ] - where - dataType = TyCon $ UnQual dataName - EnumInfo { enumName = dataName, enumDescriptor = ed } = info - constructors :: [(Name, EnumValueDescriptorProto)] - constructors = List.sortBy (comparing ((^. number) . snd)) - [(n, d) | EnumValueInfo - { enumValueName = n - , enumValueDescriptor = d - , enumAliasOf = Nothing - } <- enumValues info - ] - constructorNames = map fst constructors - minBoundName = head constructorNames - maxBoundName = last constructorNames - - constructorProtoNames = map (second (^. name)) constructors - constructorNumbers = map (second (fromIntegral . (^. number))) - constructors - - succPairs = zip constructorNames $ tail constructorNames - succDecl funName boundName thePairs = InsDecl $ FunBind $ - match funName [PApp (UnQual boundName) []] ( - "Prelude.error" @@ Lit (Syntax.String $ concat - [ show dataName, ".", show funName, ": bad argument " - , show boundName, ". This value would be out of bounds." - ])) - : - [ match funName [PApp (UnQual from) []] $ Con $ UnQual to - | (from, to) <- thePairs - ] - alias funName implName = InsDecl $ FunBind [match funName [] implName] - - defaultCon = Con $ UnQual $ head constructorNames - errorMessageExpr = "Prelude.error" - @@ ("Prelude.++" @@ Lit (Syntax.String errorMessage) - @@ ("Prelude.show" @@ "k__")) - errorMessage = "toEnum: unknown value for enum " ++ unpack (ed ^. name) - ++ ": " - -generateFieldDecls :: String -> [Decl] -generateFieldDecls fStr = - -- foo :: forall msg msg' . Field.HasField "foo" msg msg' - -- => Lens.Lens msg msg' (Field.Field "foo" msg) - -- (Field.Field "foo" msg') - -- foo = Field.field (Field.ProxySym :: Field.Proxy "foo") - [ TypeSig noLoc [f] - $ TyForall (Just ["msg", "msg'"]) - [ClassA "Data.ProtoLens.HasField" [fSym, "msg", "msg'"]] - $ "Lens.Family2.Lens" @@ "msg" @@ "msg'" - @@ ("Data.ProtoLens.Field" @@ fSym @@ "msg") - @@ ("Data.ProtoLens.Field" @@ fSym @@ "msg'") - , FunBind [match f [] - $ "Data.ProtoLens.field" - @@ ExpTypeSig noLoc "Data.ProtoLens.ProxySym" - ("Data.ProtoLens.ProxySym" @@ fSym) - ] - ] - where - f = Ident fStr - fSym = TyPromoted $ PromotedString fStr - ------------------------------------------- - --- | The Haskell types and lenses for an individual field of a message. --- This is used to generate both the data record Decl and the instances of --- HasField. -data LensInfo = LensInfo - { internalType :: Type -- ^ Internal type in the record - , fieldInstances :: [FieldInstanceInfo] -- ^ All instances of Field/HasField - } - -data FieldInstanceInfo = FieldInstanceInfo - { fieldSymbol :: String -- ^ The name of the Symbol corresponding to - -- this field. - , fieldTypeInstance :: Type -- ^ The type instance for Field, i.e., - -- type instance Field "foo" Bar = ... - , fieldAccessor :: Exp -- ^ The value of the "field" lens for this - -- field, i.e., - -- field _ = ... - } - --- | Compile information about the record field type and type/class instances --- for this particular field. -lensInfo :: SyntaxType -> Env QName -> FieldInfo -> LensInfo -lensInfo syntaxType env f = case fd ^. label of - -- data Foo = Foo { _Foo_bar :: Bar } - -- type instance Field "bar" Foo = Bar - FieldDescriptorProto'LABEL_REQUIRED -> LensInfo baseType - [FieldInstanceInfo - { fieldSymbol = baseName - , fieldTypeInstance = baseType - , fieldAccessor = rawAccessor - }] - FieldDescriptorProto'LABEL_OPTIONAL - | isDefaultingOptional syntaxType fd - -> LensInfo baseType - [FieldInstanceInfo - { fieldSymbol = baseName - , fieldTypeInstance = baseType - , fieldAccessor = rawAccessor - }] - FieldDescriptorProto'LABEL_REPEATED - -- data Foo = Foo { _Foo_bar :: Map Bar Baz } - -- type instance Field "foo" Foo = Map Bar Baz - | Just (k,v) <- getMapFields env fd -> let - mapType = "Data.Map.Map" @@ hsFieldType env (fieldDescriptor k) - @@ hsFieldType env (fieldDescriptor v) - in LensInfo mapType - [FieldInstanceInfo - { fieldSymbol = baseName - , fieldTypeInstance = mapType - , fieldAccessor = rawAccessor - }] - -- data Foo = Foo { _Foo_bar :: [Bar] } - -- type instance Field "bar" Foo = [Bar] - | otherwise -> LensInfo listType - [FieldInstanceInfo - { fieldSymbol = baseName - , fieldTypeInstance = listType - , fieldAccessor = rawAccessor - }] - -- data Foo = Foo { _Foo_bar :: Maybe Bar } - -- type instance Field "bar" Foo = Bar - -- type instance Field "maybe'bar" Foo = Maybe Bar - FieldDescriptorProto'LABEL_OPTIONAL -> LensInfo maybeType - [FieldInstanceInfo - { fieldSymbol = baseName - , fieldTypeInstance = baseType - , fieldAccessor = maybeAccessor - } - , FieldInstanceInfo - { fieldSymbol = maybeName - , fieldTypeInstance = "Prelude.Maybe" @@ baseType - , fieldAccessor = rawAccessor - } - ] - where - baseName = overloadedField f - fd = fieldDescriptor f - baseType = hsFieldType env fd - listType = TyList baseType - maybeType = "Prelude.Maybe" @@ baseType - maybeName = "maybe'" ++ baseName - maybeAccessor = "Prelude.." @@ fromString maybeName - @@ ("Data.ProtoLens.maybeLens" - @@ hsFieldValueDefault env fd) - rawAccessor = rawFieldAccessor $ UnQual $ recordFieldName f - --- Get the key/value types of this type, if it is really a map. -getMapFields :: Env QName -> FieldDescriptorProto - -> Maybe (FieldInfo, FieldInfo) -getMapFields env f - | f ^. type' == FieldDescriptorProto'TYPE_MESSAGE - , Message m@MessageInfo { messageDescriptor = d } <- definedFieldType f env - , d ^. options.mapEntry - , [f1, f2] <- messageFields m = Just (f1, f2) - | otherwise = Nothing - -hsFieldType :: Env QName -> FieldDescriptorProto -> Type -hsFieldType env fd = case fd ^. type' of - FieldDescriptorProto'TYPE_DOUBLE -> "Prelude.Double" - FieldDescriptorProto'TYPE_FLOAT -> "Prelude.Float" - FieldDescriptorProto'TYPE_INT64 -> "Data.Int.Int64" - FieldDescriptorProto'TYPE_UINT64 -> "Data.Word.Word64" - FieldDescriptorProto'TYPE_INT32 -> "Data.Int.Int32" - FieldDescriptorProto'TYPE_FIXED64 -> "Data.Word.Word64" - FieldDescriptorProto'TYPE_FIXED32 -> "Data.Word.Word32" - FieldDescriptorProto'TYPE_BOOL -> "Prelude.Bool" - FieldDescriptorProto'TYPE_STRING -> "Data.Text.Text" - FieldDescriptorProto'TYPE_GROUP - | Message m <- definedFieldType fd env -> TyCon $ messageName m - | otherwise -> error $ "expected TYPE_GROUP for type name" - ++ unpack (fd ^. typeName) - FieldDescriptorProto'TYPE_MESSAGE - | Message m <- definedFieldType fd env -> TyCon $ messageName m - | otherwise -> error $ "expected TYPE_MESSAGE for type name" - ++ unpack (fd ^. typeName) - FieldDescriptorProto'TYPE_BYTES -> "Data.ByteString.ByteString" - FieldDescriptorProto'TYPE_UINT32 -> "Data.Word.Word32" - FieldDescriptorProto'TYPE_ENUM - | Enum e <- definedFieldType fd env -> TyCon $ enumName e - | otherwise -> error $ "expected TYPE_ENUM for type name" - ++ unpack (fd ^. typeName) - FieldDescriptorProto'TYPE_SFIXED32 -> "Data.Int.Int32" - FieldDescriptorProto'TYPE_SFIXED64 -> "Data.Int.Int64" - FieldDescriptorProto'TYPE_SINT32 -> "Data.Int.Int32" - FieldDescriptorProto'TYPE_SINT64 -> "Data.Int.Int64" - -hsFieldDefault :: SyntaxType -> Env QName -> FieldDescriptorProto -> Exp -hsFieldDefault syntaxType env fd - = case fd ^. label of - FieldDescriptorProto'LABEL_OPTIONAL - | isDefaultingOptional syntaxType fd -> hsFieldValueDefault env fd - | otherwise -> "Prelude.Nothing" - FieldDescriptorProto'LABEL_REPEATED - | Just _ <- getMapFields env fd -> "Data.Map.empty" - | otherwise -> List [] - -- TODO: More sensible initialization of required fields. - FieldDescriptorProto'LABEL_REQUIRED -> hsFieldValueDefault env fd - -hsFieldValueDefault :: Env QName -> FieldDescriptorProto -> Exp -hsFieldValueDefault env fd = case fd ^. type' of - FieldDescriptorProto'TYPE_MESSAGE -> "Data.Default.Class.def" - FieldDescriptorProto'TYPE_GROUP -> "Data.Default.Class.def" - FieldDescriptorProto'TYPE_ENUM - | T.null def -> "Data.Default.Class.def" - | Enum e <- definedFieldType fd env - , Just v <- List.lookup def [ (enumValueDescriptor v ^. name, enumValueName v) - | v <- enumValues e - ] - -> Con v - | otherwise -> errorMessage "enum" - -- The rest of the cases are for scalar fields that have a fieldDefault - -- instance. - _ | T.null def -> "Data.ProtoLens.fieldDefault" - FieldDescriptorProto'TYPE_BOOL - | def == "true" -> "Prelude.True" - | def == "false" -> "Prelude.False" - | otherwise -> errorMessage "bool" - FieldDescriptorProto'TYPE_STRING - -> "Data.Text.pack" @@ Lit (String $ T.unpack def) - FieldDescriptorProto'TYPE_BYTES - -> "Data.ByteString.pack" - @@ List ((mkByte . fromEnum) <$> T.unpack def) - where mkByte c - | c > 0 && c < 255 = litInt $ fromIntegral c - | otherwise = errorMessage "bytes" - FieldDescriptorProto'TYPE_FLOAT -> defaultFrac $ T.unpack def - FieldDescriptorProto'TYPE_DOUBLE -> defaultFrac $ T.unpack def - -- Otherwise, assume it's an integral field: - _ -> defaultInt $ T.unpack def - where - def = fd ^. defaultValue - errorMessage fieldType - = error $ "Bad default value " ++ show (T.unpack def) - ++ " in default value for " ++ fieldType ++ " field " - ++ unpack (fd ^. name) - -- float/double fields can use nan, inf and -inf as default values. - -- The Prelude doesn't provide names for them, so we implement - -- them as division by zero. - defaultFrac "nan" = "Prelude./" @@ litFrac 0 @@ litFrac 0 - defaultFrac "inf" = "Prelude./" @@ litFrac 1 @@ litFrac 0 - defaultFrac "-inf" = "Prelude./" @@ litFrac (negate 1) @@ litFrac 0 - defaultFrac s = case reads s of - [(x, "")] -> litFrac $ toRational (x :: Double) - _ -> errorMessage "fractional" - defaultInt s = case reads s of - [(x, "")] -> litInt x - _ -> errorMessage "integral" - --- | A lens to access an internal field. --- --- lens _Foo_bar (\x__ y__ -> x__ { _Foo_bar = y__ }) -rawFieldAccessor :: QName -> Exp -rawFieldAccessor f = "Lens.Family2.Unchecked.lens" @@ getter @@ setter - where - getter = Var f - setter = Lambda noLoc ["x__", "y__"] - $ RecUpdate "x__" [FieldUpdate f "y__"] - -descriptorExpr :: SyntaxType -> Env QName -> MessageInfo Name -> Exp -descriptorExpr syntaxType env m - -- let foo__field_descriptor = ... - -- ... - -- in Message.MessageDescriptor - -- (Data.Map.fromList [(Tag 1, foo__field_descriptor),...]) - -- (Data.Map.fromList [("foo", foo__field_descriptor),...]) - -- - -- (Note that the two maps have the same elements but different keys. We - -- use the "let" expression to share elements between the two maps.) - = Let (BDecls $ map fieldDescriptorVarBind $ messageFields m) - $ "Data.ProtoLens.MessageDescriptor" - @@ ("Data.Map.fromList" @@ List fieldsByTag) - @@ ("Data.Map.fromList" @@ List fieldsByTextFormatName) - where - fieldsByTag = - [Tuple Boxed - [ t, fieldDescriptorVar f ] - | f <- messageFields m - , let t = "Data.ProtoLens.Tag" - @@ litInt (fromIntegral - $ fieldDescriptor f ^. number) - ] - fieldsByTextFormatName = - [Tuple Boxed - [ t, fieldDescriptorVar f ] - | f <- messageFields m - , let t = Lit $ Syntax.String $ T.unpack - $ textFormatFieldName env (fieldDescriptor f) - ] - fieldDescriptorVar = fromString . fieldDescriptorName - fieldDescriptorName f - = fromString $ overloadedField f ++ "__field_descriptor" - fieldDescriptorVarBind f - = FunBind - [match (fromString $ fieldDescriptorName f) [] - $ fieldDescriptorExpr syntaxType env f - ] - --- | Get the name of the field when used in a text format proto. Groups are --- special because their text format field name is the name of their type, --- not the name of the field in the descriptor (e.g. "Foo", not "foo"). -textFormatFieldName :: Env QName -> FieldDescriptorProto -> T.Text -textFormatFieldName env descr = case descr ^. type' of - FieldDescriptorProto'TYPE_GROUP - | Message msg <- definedFieldType descr env - -> messageDescriptor msg ^. name - | otherwise -> error $ "expected TYPE_GROUP for type name" - ++ T.unpack (descr ^. typeName) - _ -> descr ^. name - -fieldDescriptorExpr :: SyntaxType -> Env QName -> FieldInfo - -> Exp -fieldDescriptorExpr syntaxType env f - = "Data.ProtoLens.FieldDescriptor" - -- Record the .proto field name as used in text format - @@ Lit (Syntax.String $ T.unpack $ textFormatFieldName env fd) - -- Force the type signature since it can't be inferred for Map entry - -- types. - @@ ExpTypeSig noLoc (fieldTypeDescriptorExpr (fd ^. type')) - ("Data.ProtoLens.FieldTypeDescriptor" - @@ hsFieldType env fd) - @@ fieldAccessorExpr syntaxType env f - where - fd = fieldDescriptor f - -fieldAccessorExpr :: SyntaxType -> Env QName -> FieldInfo -> Exp --- (PlainField Required foo), (OptionalField foo), etc... -fieldAccessorExpr syntaxType env f = accessorCon @@ Var (UnQual hsFieldName) - where - fd = fieldDescriptor f - accessorCon = case fd ^. label of - FieldDescriptorProto'LABEL_REQUIRED - -> "Data.ProtoLens.PlainField" @@ "Data.ProtoLens.Required" - FieldDescriptorProto'LABEL_OPTIONAL - | isDefaultingOptional syntaxType fd - -> "Data.ProtoLens.PlainField" @@ "Data.ProtoLens.Optional" - | otherwise -> "Data.ProtoLens.OptionalField" - FieldDescriptorProto'LABEL_REPEATED - | Just (k, v) <- getMapFields env fd - -> "Data.ProtoLens.MapField" - @@ fromString (overloadedField k) - @@ fromString (overloadedField v) - | otherwise -> "Data.ProtoLens.RepeatedField" - @@ if isPackedField syntaxType fd - then "Data.ProtoLens.Packed" - else "Data.ProtoLens.Unpacked" - hsFieldName - = Ident $ case fd ^. label of - FieldDescriptorProto'LABEL_OPTIONAL - | not (isDefaultingOptional syntaxType fd) - -> "maybe'" ++ overloadedField f - _ -> overloadedField f - -isDefaultingOptional :: SyntaxType -> FieldDescriptorProto -> Bool -isDefaultingOptional syntaxType f - = f ^. label == FieldDescriptorProto'LABEL_OPTIONAL - && syntaxType == Proto3 - && f ^. type' /= FieldDescriptorProto'TYPE_MESSAGE - -- For now, we treat oneof's like proto2 optional fields. - && isNothing (f ^. maybe'oneofIndex) - -isPackedField :: SyntaxType -> FieldDescriptorProto -> Bool -isPackedField s f = case f ^. options . maybe'packed of - Just t -> t - -- proto3 fields are packed by default. Annoyingly, we need to - -- implement this logic manually rather than relying on protoc. - Nothing -> s == Proto3 - && f ^. type' `notElem` - [ FieldDescriptorProto'TYPE_MESSAGE - , FieldDescriptorProto'TYPE_GROUP - , FieldDescriptorProto'TYPE_STRING - , FieldDescriptorProto'TYPE_BYTES - ] - -fieldTypeDescriptorExpr :: FieldDescriptorProto'Type -> Exp -fieldTypeDescriptorExpr = - (\n -> fromString $ "Data.ProtoLens." ++ n ++ "Field") . \t -> case t of - FieldDescriptorProto'TYPE_DOUBLE -> "Double" - FieldDescriptorProto'TYPE_FLOAT -> "Float" - FieldDescriptorProto'TYPE_INT64 -> "Int64" - FieldDescriptorProto'TYPE_UINT64 -> "UInt64" - FieldDescriptorProto'TYPE_INT32 -> "Int32" - FieldDescriptorProto'TYPE_FIXED64 -> "Fixed64" - FieldDescriptorProto'TYPE_FIXED32 -> "Fixed32" - FieldDescriptorProto'TYPE_BOOL -> "Bool" - FieldDescriptorProto'TYPE_STRING -> "String" - FieldDescriptorProto'TYPE_GROUP -> "Group" - FieldDescriptorProto'TYPE_MESSAGE -> "Message" - FieldDescriptorProto'TYPE_BYTES -> "Bytes" - FieldDescriptorProto'TYPE_UINT32 -> "UInt32" - FieldDescriptorProto'TYPE_ENUM -> "Enum" - FieldDescriptorProto'TYPE_SFIXED32 -> "SFixed32" - FieldDescriptorProto'TYPE_SFIXED64 -> "SFixed64" - FieldDescriptorProto'TYPE_SINT32 -> "SInt32" - FieldDescriptorProto'TYPE_SINT64 -> "SInt64" diff --git a/src/Data/ProtoLens/Compiler/ModuleName.hs b/src/Data/ProtoLens/Compiler/ModuleName.hs new file mode 100644 --- /dev/null +++ b/src/Data/ProtoLens/Compiler/ModuleName.hs @@ -0,0 +1,23 @@ +module Data.ProtoLens.Compiler.ModuleName + ( protoModuleName ) where + +import Data.Char (toUpper) +import Data.List (intercalate) +import System.FilePath + +-- | Get the Haskell module name corresponding to a given .proto file. +protoModuleName :: FilePath -> String +protoModuleName path = fixModuleName rawModuleName + where + fixModuleName "" = "" + -- Characters allowed in Bazel filenames but not in module names: + fixModuleName ('.':c:cs) = '.' : toUpper c : fixModuleName cs + fixModuleName ('_':c:cs) = toUpper c : fixModuleName cs + fixModuleName ('-':c:cs) = toUpper c : fixModuleName cs + fixModuleName (c:cs) = c : fixModuleName cs + rawModuleName = intercalate "." + . (prefix :) + . splitDirectories $ dropExtension path + +prefix :: String +prefix = "Proto" diff --git a/src/Data/ProtoLens/Compiler/Plugin.hs b/src/Data/ProtoLens/Compiler/Plugin.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Plugin.hs +++ /dev/null @@ -1,125 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd --- --- Code for writing protocol compiler plugins. - -{-# LANGUAGE OverloadedStrings #-} -module Data.ProtoLens.Compiler.Plugin - ( ProtoFileName - , ProtoFile(..) - , analyzeProtoFiles - , collectEnvFromDeps - , outputFilePath - , moduleName - , moduleNameStr - ) where - -import Data.Char (toUpper) -import Data.List (foldl', intercalate) -import qualified Data.Map.Strict as Map -import Data.Map.Strict (Map, unions, (!)) -import Data.Monoid ((<>)) -import qualified Data.Text as T -import Data.Text (Text) -import Language.Haskell.Exts.Syntax (ModuleName(..), Name(..), QName(..)) -import Lens.Family2 -import Proto.Google.Protobuf.Descriptor - (FileDescriptorProto, name, dependency, publicDependency) -import System.FilePath (dropExtension, splitDirectories) - - -import Data.ProtoLens.Compiler.Definitions - --- | The filename of an input .proto file. -type ProtoFileName = Text - -data ProtoFile = ProtoFile - { descriptor :: FileDescriptorProto - , haskellModule :: ModuleName - , definitions :: Env Name - -- | The names of proto files exported (transitively, via "import public" - -- decl) by this file. - , exports :: [ProtoFileName] - , exportedEnv :: Env QName - } - --- Given a list of FileDescriptorProtos, collect information about each file --- into a map of 'ProtoFile's keyed by 'ProtoFileName'. -analyzeProtoFiles :: Text -> [FileDescriptorProto] -> Map ProtoFileName ProtoFile -analyzeProtoFiles modulePrefix files = - Map.fromList [ (f ^. name, ingestFile f) | f <- files ] - where - filesByName = Map.fromList [(f ^. name, f) | f <- files] - moduleNames = fmap (moduleName modulePrefix) filesByName - -- The definitions in each input proto file, indexed by filename. - definitionsByName = fmap collectDefinitions filesByName - -- The exports from each .proto file (including any "public import" - -- dependencies), as they appear to other modules that are importing them; - -- i.e., qualified by module name. - exportsByName = transitiveExports files - localExports = Map.intersectionWith qualifyEnv moduleNames definitionsByName - exportedEnvs = fmap (\es -> unions [localExports ! e | e <- es]) exportsByName - - ingestFile f = ProtoFile - { descriptor = f - , haskellModule = moduleNames ! n - , definitions = definitionsByName ! n - , exports = exportsByName ! n - , exportedEnv = exportedEnvs ! n - } - where - n = f ^. name - -collectEnvFromDeps :: [ProtoFileName] -> Map ProtoFileName ProtoFile -> Env QName -collectEnvFromDeps deps filesByName = - unions $ fmap (exportedEnv . (filesByName !)) deps - --- | Get the output file path (for CodeGeneratorResponse.File) for a Haskell --- ModuleName. -outputFilePath :: String -> Text -outputFilePath n = T.replace "." "/" (T.pack n) <> ".hs" - --- | Get the Haskell 'ModuleName' corresponding to a given .proto file. -moduleName :: Text -> FileDescriptorProto -> ModuleName -moduleName modulePrefix fd = ModuleName (moduleNameStr modulePrefix fd) - --- | Get the Haskell module name corresponding to a given .proto file. -moduleNameStr :: Text -> FileDescriptorProto -> String -moduleNameStr prefix fd = fixModuleName rawModuleName - where - path = fd ^. name - fixModuleName "" = "" - -- Characters allowed in Bazel filenames but not in module names: - fixModuleName ('.':c:cs) = '.' : toUpper c : fixModuleName cs - fixModuleName ('_':c:cs) = toUpper c : fixModuleName cs - fixModuleName ('-':c:cs) = toUpper c : fixModuleName cs - fixModuleName (c:cs) = c : fixModuleName cs - rawModuleName = intercalate "." $ (T.unpack prefix :) - $ splitDirectories $ dropExtension - $ T.unpack path - --- | Given a list of .proto files (topologically sorted), determine which --- files' definitions are exported by which files. --- --- Files only export their own definitions, along with the definitions exported --- by any "import public" declarations. -transitiveExports :: [FileDescriptorProto] -> Map ProtoFileName [ProtoFileName] --- Accumulate the transitive dependencies by folding over the files in --- topological order. -transitiveExports = foldl' setExportsFromFile Map.empty - where - setExportsFromFile :: Map ProtoFileName [ProtoFileName] - -> FileDescriptorProto - -> Map ProtoFileName [ProtoFileName] - setExportsFromFile prevExports fd - = flip (Map.insert n) prevExports $ - n : concat [ prevExports ! ((fd ^. dependency) !! fromIntegral i) - -- Note that publicDependency is a list of indices into - -- the dependency list. - | i <- fd ^. publicDependency - ] - where n = fd ^. name - diff --git a/src/Data/ProtoLens/Setup.hs b/src/Data/ProtoLens/Setup.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Setup.hs +++ /dev/null @@ -1,195 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd - --- | Helper functions to generate proto files as part of a @Setup.hs@ script. --- --- These functions assume that the @proto-lens-protoc@ executable is on the --- PATH, and throw an exception otherwise. That executable will be installed --- automatically as part of installing this package; in particular, it should --- be enough to just list `proto-lens-protoc` in a user package's --- `build-dependencies`. --- --- See @README.md@ for instructions on how to use proto-lens with Cabal. -{-# LANGUAGE CPP #-} -module Data.ProtoLens.Setup - ( defaultMainGeneratingProtos - , defaultMainGeneratingSpecificProtos - , generatingProtos - , generatingSpecificProtos - , generateProtos - ) where - -#if __GLASGOW_HASKELL__ < 709 -import Data.Functor ((<$>)) -#endif - -import Distribution.PackageDescription - ( PackageDescription(..) - , benchmarkBuildInfo - , buildInfo - , extraSrcFiles - , hsSourceDirs - , libBuildInfo - , testBuildInfo - ) -import Distribution.Simple.BuildPaths (autogenModulesDir) -import Distribution.Simple.LocalBuildInfo (LocalBuildInfo) -import Distribution.Simple.Utils (matchFileGlob) -import Distribution.Simple - ( defaultMainWithHooks - , simpleUserHooks - , UserHooks(..) - ) -import System.FilePath - ( () - , equalFilePath - , isRelative - , makeRelative - , takeExtension - ) -import System.Directory (createDirectoryIfMissing, findExecutable) -import System.Process (callProcess) - --- | This behaves the same as 'Distribution.Simple.defaultMain', but --- auto-generates Haskell files from the .proto files listed in --- the @.cabal@ file under @extra-source-files@ which are located under the --- given root directory. --- --- Writes the generated files to the autogen directory (@dist\/build\/autogen@ --- for Cabal, and @.stack-work\/dist\/...\/build\/autogen@ for stack). --- --- Throws an exception if the @proto-lens-protoc@ executable is not on the PATH. -defaultMainGeneratingProtos - :: FilePath -- ^ The root directory under which .proto files can be found. - -> IO () -defaultMainGeneratingProtos root - = defaultMainWithHooks $ generatingProtos root simpleUserHooks - --- | This behaves the same as 'Distribution.Simple.defaultMain', but --- auto-generates Haskell files from the .proto files listed. The given .proto --- files should be under the given root directory. --- --- Writes the generated files to the autogen directory (@dist\/build\/autogen@ --- for Cabal, and @.stack-work\/dist\/...\/build\/autogen@ for stack). --- --- Throws an exception if the @proto-lens-protoc@ executable is not on the PATH. -defaultMainGeneratingSpecificProtos - :: FilePath -- ^ The root directory under which .proto files can be found. - -> (PackageDescription -> IO [FilePath]) - -- ^ A function to return a list of .proto files. Takes the Cabal package - -- description as input. Non-absolute paths are treated as relative to the - -- provided root directory. - -> IO () -defaultMainGeneratingSpecificProtos root getProtos - = defaultMainWithHooks - $ generatingSpecificProtos root getProtos simpleUserHooks - --- | Augment the given 'UserHooks' to auto-generate Haskell files from the --- .proto files listed in the @.cabal@ file under @extra-source-files@ which --- are located under the given root directory. --- --- Writes the generated files to the autogen directory (@dist\/build\/autogen@ --- for Cabal, and @.stack-work\/dist\/...\/build\/autogen@ for stack). --- --- Throws an exception if the @proto-lens-protoc@ executable is not on the PATH. -generatingProtos - :: FilePath -- ^ The root directory under which .proto files can be found. - -> UserHooks -> UserHooks -generatingProtos root = generatingSpecificProtos root getProtos - where - getProtos p = do - -- Replicate Cabal's own logic for parsing file globs. - files <- concat <$> mapM matchFileGlob (extraSrcFiles p) - pure $ map (makeRelative root) - $ filter (isSubdirectoryOf root) - $ filter (\f -> takeExtension f == ".proto") - files - --- | Augment the given 'UserHooks' to auto-generate Haskell files from the --- .proto files returned by a function @getProtos@. --- --- Writes the generated files to the autogen directory (@dist\/build\/autogen@ --- for Cabal, and @.stack-work\/dist\/...\/build\/autogen@ for stack). --- --- Throws an exception if the @proto-lens-protoc@ executable is not on the PATH. -generatingSpecificProtos - :: FilePath -- ^ The root directory under which .proto files can be found. - -> (PackageDescription -> IO [FilePath]) - -- ^ A function to return a list of .proto files. Takes the Cabal package - -- description as input. Non-absolute paths are treated as relative to the - -- provided root directory. - -> UserHooks -> UserHooks -generatingSpecificProtos root getProtos hooks = hooks - { buildHook = \p l h f -> generateSources p l >> buildHook hooks p l h f - , haddockHook = \p l h f -> generateSources p l >> haddockHook hooks p l h f - , replHook = \p l h f args -> generateSources p l - >> replHook hooks p l h f args - , sDistHook = \p maybe_l h f -> case maybe_l of - Nothing -> error "Can't run protoc; run 'cabal configure' first." - Just l -> do - generateSources p l - sDistHook hooks (fudgePackageDesc l p) maybe_l h f - } - where - generateSources p l = do - -- Applying 'root ' does nothing if the path is already absolute. - files <- map (root ) <$> getProtos p - generateProtos root (autogenModulesDir l) files - --- | Add the autogen directory to the hs-source-dirs of all the targets in the --- .cabal file. Used to fool 'sdist' by pointing it to the generated source --- files. -fudgePackageDesc :: LocalBuildInfo -> PackageDescription -> PackageDescription -fudgePackageDesc lbi p = p - { library = - (\lib -> lib { libBuildInfo = fudgeBuildInfo (libBuildInfo lib) }) - <$> library p - , executables = - (\exe -> exe { buildInfo = fudgeBuildInfo (buildInfo exe) }) - <$> executables p - , testSuites = - (\test -> test { testBuildInfo = fudgeBuildInfo (testBuildInfo test) }) - <$> testSuites p - , benchmarks = - (\bench -> bench { benchmarkBuildInfo = - fudgeBuildInfo (benchmarkBuildInfo bench) }) - <$> benchmarks p - } - where - fudgeBuildInfo bi = - bi { hsSourceDirs = autogenModulesDir lbi : hsSourceDirs bi } - --- | Returns whether the @root@ is a parent folder of @f@. -isSubdirectoryOf :: FilePath -> FilePath -> Bool -isSubdirectoryOf root f - = isRelative f - -- Note: `makeRelative root f` returns `f` when f doesn't live under the - -- root. - && equalFilePath f (root makeRelative root f) - --- | Run the proto compiler to generate Haskell files from the given .proto files. --- --- Writes the generated files to the autogen directory (@dist\/build\/autogen@ --- for Cabal, and @.stack-work\/dist\/...\/build\/autogen@ for stack). --- --- Throws an exception if the @proto-lens-protoc@ executable is not on the PATH. -generateProtos - :: FilePath -- ^ The root directory under which .proto files can be found. - -> FilePath -- ^ The output directory for the generated Haskell files. - -> [FilePath] -- ^ The .proto files to process. - -> IO () -generateProtos root output files = do - maybeProtoLensProtoc <- findExecutable "proto-lens-protoc" - case maybeProtoLensProtoc of - Nothing -> error "Couldn't find executable proto-lens-protoc." - Just protoLensProtoc -> do - createDirectoryIfMissing True output - callProcess "protoc" $ - [ "--plugin=protoc-gen-haskell=" ++ protoLensProtoc - , "--haskell_out=" ++ output - , "--proto_path=" ++ root - ] - ++ files diff --git a/src/protoc-gen-haskell.hs b/src/protoc-gen-haskell.hs deleted file mode 100644 --- a/src/protoc-gen-haskell.hs +++ /dev/null @@ -1,96 +0,0 @@ --- Copyright 2016 Google Inc. All Rights Reserved. --- --- Use of this source code is governed by a BSD-style --- license that can be found in the LICENSE file or at --- https://developers.google.com/open-source/licenses/bsd - -{-# LANGUAGE OverloadedStrings #-} -module Main where - -import qualified Data.ByteString as B -import Data.Char (toUpper) -import Data.List (foldl', intercalate) -import qualified Data.Map.Strict as Map -import Data.Map.Strict (Map, unions, (!)) -import Data.Monoid ((<>)) -import qualified Data.Set as Set -import qualified Data.Text as T -import Data.Text (Text, pack) -import Data.ProtoLens (decodeMessage, def, encodeMessage) -import Language.Haskell.Exts.Pretty (prettyPrint) -import Language.Haskell.Exts.Syntax (ModuleName(..), Name(..), QName(..)) -import Lens.Family2 -import Proto.Google.Protobuf.Compiler.Plugin - ( CodeGeneratorRequest - , CodeGeneratorResponse - , content - , file - , fileToGenerate - , parameter - , protoFile - ) -import Proto.Google.Protobuf.Descriptor - (FileDescriptorProto, name, dependency, publicDependency) -import System.Environment (getProgName) -import System.Exit (exitWith, ExitCode(..)) -import System.IO as IO -import System.FilePath (dropExtension, replaceExtension, splitDirectories) -import Text.Read (readEither) - -import Data.ProtoLens.Compiler.Definitions -import Data.ProtoLens.Compiler.Generate -import Data.ProtoLens.Compiler.Plugin -import System.Environment (getArgs) - -main = do - contents <- B.getContents - progName <- getProgName - args <- getArgs - case decodeMessage contents of - Left e -> IO.hPutStrLn stderr e >> exitWith (ExitFailure 1) - Right x -> B.putStr $ encodeMessage $ makeResponse progName x - -makeResponse :: String -> CodeGeneratorRequest -> CodeGeneratorResponse -makeResponse prog request = let - useReexport = case T.unpack $ request ^. parameter of - "" -> reexported - "no-reexports" -> id - p -> error $ "Error reading parameter: " ++ show p - outputFiles = generateFiles useReexport header - (request ^. protoFile) - (request ^. fileToGenerate) - header :: FileDescriptorProto -> Text - header f = "{- This file was auto-generated from " - <> (f ^. name) - <> " by the " <> pack prog <> " program. -}\n" - in def & file .~ [ def & name .~ outputName - & content .~ outputContent - | (outputName, outputContent) <- outputFiles - ] - - -generateFiles :: ModifyImports -> (FileDescriptorProto -> Text) - -> [FileDescriptorProto] -> [ProtoFileName] -> [(Text, Text)] -generateFiles modifyImports header files toGenerate = let - modulePrefix = "Proto" - filesByName = analyzeProtoFiles modulePrefix files - -- The contents of the generated Haskell file for a given .proto file. - buildFile file = let - deps = descriptor file ^. dependency - imports = Set.toAscList $ Set.fromList - [ haskellModule (filesByName ! exportName) - | dep <- deps - , exportName <- exports (filesByName ! dep) - ] - in generateModule (haskellModule file) imports - (fileSyntaxType (descriptor file)) - modifyImports - (definitions file) - (collectEnvFromDeps deps filesByName) - in [ ( outputFilePath . (\(ModuleName n) -> n) . haskellModule $ file - , header (descriptor file) <> pack (prettyPrint $ buildFile file) - ) - | fileName <- toGenerate - , let file = filesByName ! fileName - ] -