diff --git a/Changelog.md b/Changelog.md --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,23 @@ # Changelog for `proto-lens-protoc` +## v0.6.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 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,631 @@ +-- 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 Control.Applicative (liftA2) +import Data.Char (isUpper, toUpper) +import Data.Int (Int32) +import Data.List (mapAccumL) +import qualified Data.Map as Map +import Data.Maybe (fromMaybe) +#if !MIN_VERSION_base(4,11,0) +import Data.Monoid ((<>)) +#endif +import Data.ProtoLens.Labels () +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 + , EnumDescriptorProto + , EnumValueDescriptorProto + , 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) + +data SyntaxType = Proto2 | Proto3 + deriving (Show, 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 + +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. + , messageOneofFields :: [OneofInfo] + -- ^ The oneofs in this message, associated with the fields that + -- belong to them. + , 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] + } + +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 optional 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, + -- 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 -> Env OccNameStr +collectDefinitions fd = let + protoPrefix = case fd ^. #package of + "" -> "." + p -> "." <> p <> "." + hsPrefix = "" + in Map.fromList $ concatMap flatten $ + messageAndEnumDefs (fileSyntaxType fd) + 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 + } + + 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 :: + SyntaxType -> 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 syntaxType protoPrefix hsPrefix groups messages enums + = map (messageDefs syntaxType protoPrefix hsPrefix groups) messages + ++ map + (flip Node [] -- Enums have no sub-definitions + . enumDef syntaxType protoPrefix hsPrefix) + enums + +-- | Generate the definitions for a message and its nested types (if any). +messageDefs :: SyntaxType -> Text -> String -> GroupMap -> DescriptorProto + -> Tree (Text, Definition OccNameStr) +messageDefs syntaxType 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 (liftA2 PlainFieldInfo + (fieldKind syntaxType mapEntries) (fieldInfo hsPrefix')) + $ Map.findWithDefault [] Nothing allFields + , messageOneofFields = collectOneofFields hsPrefix' d allFields + , messageUnknownFields = + fromString $ "_" ++ hsPrefix' ++ "_unknownFields" + , groupFieldNumber = Map.lookup protoName groups + } + subDefs = messageAndEnumDefs + syntaxType + (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 + +-- | 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 + ] + +fieldInfo :: String -> FieldDescriptorProto -> FieldInfo +fieldInfo hsPrefix f = FieldInfo + { fieldDescriptor = f + , fieldName = mkFieldName hsPrefix $ f ^. #name + } + +fieldKind :: + SyntaxType -> Map.Map Text MapEntryInfo -> FieldDescriptorProto + -> FieldKind +fieldKind syntaxType mapEntries f = case f ^. #label of + FieldDescriptorProto'LABEL_OPTIONAL + | syntaxType == Proto3 + && f ^. #type' /= FieldDescriptorProto'TYPE_MESSAGE + -> OptionalValueField + | otherwise -> OptionalMaybeField + 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 + -- If the "packed" attribute isn't set, then default to packed if proto3. + -- Unfortunately, protoc doesn't implement this logic for us automatically. + packedByDefault = fromMaybe (syntaxType == Proto3) + $ f ^. #options . #maybe'packed + unpackableTypes = + [ FieldDescriptorProto'TYPE_MESSAGE + , FieldDescriptorProto'TYPE_GROUP + , FieldDescriptorProto'TYPE_STRING + , FieldDescriptorProto'TYPE_BYTES + ] + +collectOneofFields + :: String -> DescriptorProto -> Map.Map (Maybe Int32) [FieldDescriptorProto] + -> [OneofInfo] +collectOneofFields hsPrefix d allFields + = zipWith oneofInfo [0..] $ d ^.. #oneofDecl . traverse . #name + where + oneofInfo idx n = OneofInfo + { oneofFieldName = mkFieldName hsPrefix n + , oneofTypeName = fromString $ hsPrefix ++ hsNameUnique subdefTypes n + , oneofCases = map oneofCase + $ Map.findWithDefault [] (Just idx) + allFields + } + 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.) +groupFieldsByOneofIndex + :: [FieldDescriptorProto] -> Map.Map (Maybe Int32) [FieldDescriptorProto] +groupFieldsByOneofIndex = + fmap reverse + . Map.fromListWith (++) + . fmap (\f -> (f ^. #maybe'oneofIndex, [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", "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 :: SyntaxType -> Text -> String -> EnumDescriptorProto + -> (Text, Definition OccNameStr) +enumDef syntaxType protoPrefix hsPrefix d = let + mkText n = protoPrefix <> n + mkHsName n = fromString $ hsPrefix ++ case hsName n of + ('_':xs) -> 'X':xs + xs -> xs + in (mkText (d ^. #name) + , Enum EnumInfo + { enumName = mkHsName (d ^. #name) + , enumUnrecognized = if syntaxType == Proto2 + then Nothing + else Just EnumUnrecognizedInfo + { unrecognizedName + = mkHsName (d ^. #name <> "'Unrecognized") + , unrecognizedValueName + = mkHsName (d ^. #name <> "'UnrecognizedValue") + } + , 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/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,1054 @@ +-- 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 +import HsSyn (ideclName, ideclAs) +import Module (moduleNameString, mkModuleName) +import qualified Outputable +import SrcLoc (unLoc, noLoc) +import Lens.Family2 ((^.)) +import Text.Printf (printf) + +import Proto.Google.Protobuf.Descriptor + ( EnumValueDescriptorProto + , 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 + ) + +-- 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 + -> [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 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) + , 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"] + -- 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 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 + 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"] + [ 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 + ] + ] + ] ++ + -- 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 + 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")] + ] + [deriving' [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 + ] + [deriving' [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"]) + [deriving' [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] + ] + ) + [deriving' [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 $ head constructorNames + + minBoundName = head constructorNames + maxBoundName = last constructorNames + + constructorNumbers = map (second (fromIntegral . (^. #number))) constructors + + succPairs = zip constructorNames $ tail constructorNames + + 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) + , 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 + 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. + 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 (@@) unit (map seqField 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,48 @@ +-- | Enables pretty-printing Haddock comments along with top-level declarations. +module Data.ProtoLens.Compiler.Generate.Commented where + +import Data.Maybe (fromMaybe) +import GHC.SourceGen +import Outputable (Outputable(..), SDoc, (<+>), ($+$), vcat, empty, text) +import HsSyn (hsmodName) +import GHC (ModuleName) +import SrcLoc (unLoc) + +-- | 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 = + fromMaybe (error $ "getModuleName: No explicit name") + $ fmap 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,638 @@ +-- | This module generates code for decoding and encoding protocol buffer messages. +-- +-- Upstream docs: +{-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE LambdaCase #-} +{-# 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 (view, (^.)) +import GHC.SourceGen + +import Data.ProtoLens.Compiler.Definitions +import Data.ProtoLens.Compiler.Generate.Field +import Data.ProtoLens.Encoding.Wire (joinTypeAndTag) + +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 <-- 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) + ++ [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) + +-- | 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 = fieldEncoding . view #type' . fieldDescriptor + +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,261 @@ +{-# 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 + } + +-- | Wrap a field encoding with Haskell functions that may fail during parsing. +partialField :: HsExpr' -> (HsExpr' -> HsExpr') -> FieldEncoding -> FieldEncoding +partialField buildF parseF f = FieldEncoding + { buildFieldType = var "Prelude.." @@ buildFieldType f @@ buildF + -- do + -- value <- ... + -- runEither $ {parseF} value + , parseFieldType = do' + [ value <-- parseFieldType f + , stmt $ runEither @@ parseF value + ] + , wireType = wireType f + } + where + value = bvar "value" + runEither = var "Data.ProtoLens.Encoding.Bytes.runEither" + +-- | 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 = partialField (var "Data.Text.Encoding.encodeUtf8") decodeUtf8P lengthy + where + {- Translates to: + case decodeUtf8' bytes of + Left err -> Left (show err) + Right r -> r + Equivalently: + first show $ decodeUtf8' bytes + but avoids dragging in Data.Bifunctors. + -} + decodeUtf8P bytes = + case' (var "Data.Text.Encoding.decodeUtf8'" @@ bytes) + [ match ["Prelude.Left" `conP` [bvar "err"]] + $ var "Prelude.Left" @@ (var "Prelude.show" @@ var "err") + , match ["Prelude.Right" `conP` [bvar "r"]] + $ var "Prelude.Right" @@ var "r" + ] + +-- | 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 #-} +{-# LANGUAGE OverloadedStrings #-} +module Data.ProtoLens.Compiler.Plugin + ( ProtoFileName + , ProtoFile(..) + , analyzeProtoFiles + , collectEnvFromDeps + ) where + +import Data.List (foldl') +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] -> Map ProtoFileName ProtoFile +analyzeProtoFiles files = + Map.fromList [ (f ^. #name, ingestFile f) | f <- files ] + where + filesByName = Map.fromList [(f ^. #name, f) | f <- files] + moduleNames = fmap fdModuleName filesByName + -- The definitions in each input proto file, indexed by filename. + definitionsByName = fmap collectDefinitions filesByName + servicesByName = fmap collectServices filesByName + exportsByName = transitiveExports files + exportedEnvs = fmap (foldMap (definitionsByName !)) exportsByName + + 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 + ] + +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 = 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,1039 @@ +{- 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#-} +{-# OPTIONS_GHC -Wno-unused-imports#-} +{-# OPTIONS_GHC -Wno-duplicate-exports#-} +{-# OPTIONS_GHC -Wno-dodgy-exports#-} +module Proto.Google.Protobuf.Compiler.Plugin ( + CodeGeneratorRequest(), CodeGeneratorResponse(), + 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.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'compilerVersion :: !(Prelude.Maybe Version), + _CodeGeneratorRequest'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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.Bytes.Parser CodeGeneratorRequest + loop x mutable'fileToGenerate mutable'protoFile + = 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) + (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 x))) + else + do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt + case tag of + 10 + -> do !y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "file_to_generate" + v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO + (Data.ProtoLens.Encoding.Growing.append + mutable'fileToGenerate y) + loop x v mutable'protoFile + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "parameter" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"parameter") y x) + mutable'fileToGenerate + mutable'protoFile + 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 + 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 + wire + -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire + wire + loop + (Lens.Family2.over + Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) + mutable'fileToGenerate + mutable'protoFile + 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 + loop + Data.ProtoLens.defMessage mutable'fileToGenerate mutable'protoFile) + "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.<>) + (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'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.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'file :: !(Data.Vector.Vector CodeGeneratorResponse'File), + _CodeGeneratorResponse'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "error" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"error") 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.<>) + (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'file 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)@ -} +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'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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.Message CodeGeneratorResponse'File where + messageName _ + = Data.Text.pack + "google.protobuf.compiler.CodeGeneratorResponse.File" + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (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 + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, insertionPoint__field_descriptor), + (Data.ProtoLens.Tag 15, content__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _CodeGeneratorResponse'File'_unknownFields + (\ x__ y__ + -> x__ {_CodeGeneratorResponse'File'_unknownFields = y__}) + defMessage + = CodeGeneratorResponse'File'_constructor + {_CodeGeneratorResponse'File'name = Prelude.Nothing, + _CodeGeneratorResponse'File'insertionPoint = Prelude.Nothing, + _CodeGeneratorResponse'File'content = 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "insertion_point" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"insertionPoint") y x) + 122 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "content" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"content") 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.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__) ()))) +{- | 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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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__) ())))) 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,181 @@ +{- 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#-} +{-# 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" +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" +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'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'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" +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" +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" +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" 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,9947 @@ +{- 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#-} +{-# 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(), EnumDescriptorProto(), + EnumDescriptorProto'EnumReservedRange(), EnumOptions(), + EnumValueDescriptorProto(), EnumValueOptions(), + ExtensionRangeOptions(), FieldDescriptorProto(), + FieldDescriptorProto'Label(..), FieldDescriptorProto'Label(), + FieldDescriptorProto'Type(..), FieldDescriptorProto'Type(), + FieldOptions(), FieldOptions'CType(..), FieldOptions'CType(), + FieldOptions'JSType(..), FieldOptions'JSType(), + FileDescriptorProto(), FileDescriptorSet(), FileOptions(), + FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(), + GeneratedCodeInfo(), GeneratedCodeInfo'Annotation(), + MessageOptions(), MethodDescriptorProto(), MethodOptions(), + 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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 (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" + 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 (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" + 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__) ())) +{- | 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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 (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" + 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.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'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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 + 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.<>) + (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'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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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.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'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _EnumValueOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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 + 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.<>) + (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'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)@ -} +data ExtensionRangeOptions + = ExtensionRangeOptions'_constructor {_ExtensionRangeOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _ExtensionRangeOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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.Message ExtensionRangeOptions where + messageName _ + = Data.Text.pack "google.protobuf.ExtensionRangeOptions" + 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 + in + Data.Map.fromList + [(Data.ProtoLens.Tag 999, uninterpretedOption__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'_unknownFields = []} + parseMessage + = let + loop :: + ExtensionRangeOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser ExtensionRangeOptions + 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 + 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) + "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.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__) ()) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' FieldDescriptorProto Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.label' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Label@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'label' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldDescriptorProto'Label)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Type@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldDescriptorProto'Type)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.typeName' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'typeName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.extendee' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'extendee' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.defaultValue' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'defaultValue' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.oneofIndex' @:: Lens' FieldDescriptorProto Data.Int.Int32@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'oneofIndex' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.jsonName' @:: Lens' FieldDescriptorProto Data.Text.Text@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FieldDescriptorProto FieldOptions@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldOptions)@ -} +data FieldDescriptorProto + = FieldDescriptorProto'_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'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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.Message FieldDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FieldDescriptorProto" + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (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 + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 3, number__field_descriptor), + (Data.ProtoLens.Tag 4, label__field_descriptor), + (Data.ProtoLens.Tag 5, type'__field_descriptor), + (Data.ProtoLens.Tag 6, typeName__field_descriptor), + (Data.ProtoLens.Tag 2, extendee__field_descriptor), + (Data.ProtoLens.Tag 7, defaultValue__field_descriptor), + (Data.ProtoLens.Tag 9, oneofIndex__field_descriptor), + (Data.ProtoLens.Tag 10, jsonName__field_descriptor), + (Data.ProtoLens.Tag 8, options__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_FieldDescriptorProto'_unknownFields = y__}) + 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'_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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "type_name" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"typeName") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "extendee" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"extendee") y x) + 58 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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) + 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.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__) ())))))))))) +data FieldDescriptorProto'Label + = FieldDescriptorProto'LABEL_OPTIONAL | + FieldDescriptorProto'LABEL_REQUIRED | + FieldDescriptorProto'LABEL_REPEATED + deriving (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_REQUIRED = "LABEL_REQUIRED" + showEnum FieldDescriptorProto'LABEL_REPEATED = "LABEL_REPEATED" + readEnum k + | (Prelude.==) k "LABEL_OPTIONAL" + = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL + | (Prelude.==) k "LABEL_REQUIRED" + = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED + | (Prelude.==) k "LABEL_REPEATED" + = Prelude.Just FieldDescriptorProto'LABEL_REPEATED + | 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 (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.deprecated' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.weak' @:: Lens' FieldOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'weak' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FieldOptions [UninterpretedOption]@ + * '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'deprecated :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'weak :: !(Prelude.Maybe Prelude.Bool), + _FieldOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _FieldOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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 "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" + 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 + 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 + 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 3, deprecated__field_descriptor), + (Data.ProtoLens.Tag 10, weak__field_descriptor), + (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FieldOptions'_unknownFields + (\ x__ y__ -> x__ {_FieldOptions'_unknownFields = y__}) + defMessage + = FieldOptions'_constructor + {_FieldOptions'ctype = Prelude.Nothing, + _FieldOptions'packed = Prelude.Nothing, + _FieldOptions'jstype = Prelude.Nothing, + _FieldOptions'lazy = Prelude.Nothing, + _FieldOptions'deprecated = Prelude.Nothing, + _FieldOptions'weak = Prelude.Nothing, + _FieldOptions'uninterpretedOption = Data.Vector.Generic.empty, + _FieldOptions'_unknownFields = []} + parseMessage + = let + loop :: + FieldOptions + -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption + -> Data.ProtoLens.Encoding.Bytes.Parser FieldOptions + 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.toEnum + (Prelude.fmap + Prelude.fromIntegral + Data.ProtoLens.Encoding.Bytes.getVarInt)) + "ctype" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"ctype") y x) + 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'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'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'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 + 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'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) + "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'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.<>) + (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'deprecated x__) + (Control.DeepSeq.deepseq + (_FieldOptions'weak x__) + (Control.DeepSeq.deepseq + (_FieldOptions'uninterpretedOption x__) ()))))))) +data FieldOptions'CType + = FieldOptions'STRING | + FieldOptions'CORD | + FieldOptions'STRING_PIECE + deriving (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__ () +data FieldOptions'JSType + = FieldOptions'JS_NORMAL | + FieldOptions'JS_STRING | + FieldOptions'JS_NUMBER + deriving (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__ () +{- | 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)@ -} +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'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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.Message FileDescriptorProto where + messageName _ + = Data.Text.pack "google.protobuf.FileDescriptorProto" + fieldsByTag + = let + name__field_descriptor + = Data.ProtoLens.FieldDescriptor + "name" + (Data.ProtoLens.ScalarField Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.OptionalField + (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 + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, name__field_descriptor), + (Data.ProtoLens.Tag 2, package__field_descriptor), + (Data.ProtoLens.Tag 3, dependency__field_descriptor), + (Data.ProtoLens.Tag 10, publicDependency__field_descriptor), + (Data.ProtoLens.Tag 11, weakDependency__field_descriptor), + (Data.ProtoLens.Tag 4, messageType__field_descriptor), + (Data.ProtoLens.Tag 5, enumType__field_descriptor), + (Data.ProtoLens.Tag 6, service__field_descriptor), + (Data.ProtoLens.Tag 7, extension__field_descriptor), + (Data.ProtoLens.Tag 8, options__field_descriptor), + (Data.ProtoLens.Tag 9, sourceCodeInfo__field_descriptor), + (Data.ProtoLens.Tag 12, syntax__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _FileDescriptorProto'_unknownFields + (\ x__ y__ -> x__ {_FileDescriptorProto'_unknownFields = y__}) + 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'_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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 + 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.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__) ())))))))))))) +{- | 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 (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" + 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.phpGenericServices' @:: Lens' FileOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpGenericServices' @:: 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.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'phpGenericServices :: !(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'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _FileOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "phpGenericServices" Prelude.Bool where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpGenericServices + (\ x__ y__ -> x__ {_FileOptions'phpGenericServices = y__})) + (Data.ProtoLens.maybeLens Prelude.False) +instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpGenericServices" (Prelude.Maybe Prelude.Bool) where + fieldOf _ + = (Prelude..) + (Lens.Family2.Unchecked.lens + _FileOptions'phpGenericServices + (\ x__ y__ -> x__ {_FileOptions'phpGenericServices = 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.False) +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 "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" + 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 + phpGenericServices__field_descriptor + = Data.ProtoLens.FieldDescriptor + "php_generic_services" + (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.OptionalField + (Data.ProtoLens.Field.field @"maybe'phpGenericServices")) :: + 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 + 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 42, phpGenericServices__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 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'phpGenericServices = 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'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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "java_package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"javaPackage") y x) + mutable'uninterpretedOption + 66 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 + 336 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (Prelude.fmap + ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt) + "php_generic_services" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpGenericServices") 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "objc_class_prefix" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"objcClassPrefix") y x) + mutable'uninterpretedOption + 298 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "csharp_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"csharpNamespace") y x) + mutable'uninterpretedOption + 314 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "swift_prefix" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"swiftPrefix") y x) + mutable'uninterpretedOption + 322 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "php_class_prefix" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpClassPrefix") y x) + mutable'uninterpretedOption + 330 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "php_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpNamespace") y x) + mutable'uninterpretedOption + 354 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "php_metadata_namespace" + loop + (Lens.Family2.set + (Data.ProtoLens.Field.field @"phpMetadataNamespace") y x) + mutable'uninterpretedOption + 362 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "ruby_package" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"rubyPackage") 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'phpGenericServices") + _x + of + Prelude.Nothing -> Data.Monoid.mempty + (Prelude.Just _v) + -> (Data.Monoid.<>) + (Data.ProtoLens.Encoding.Bytes.putVarInt 336) + ((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.<>) + (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'phpGenericServices 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'uninterpretedOption + x__) + ()))))))))))))))))))))) +data FileOptions'OptimizeMode + = FileOptions'SPEED | + FileOptions'CODE_SIZE | + FileOptions'LITE_RUNTIME + deriving (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 (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" + 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)@ -} +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'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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.Message GeneratedCodeInfo'Annotation where + messageName _ + = Data.Text.pack "google.protobuf.GeneratedCodeInfo.Annotation" + fieldsByTag + = let + path__field_descriptor + = Data.ProtoLens.FieldDescriptor + "path" + (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.RepeatedField + Data.ProtoLens.Packed (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 + in + Data.Map.fromList + [(Data.ProtoLens.Tag 1, path__field_descriptor), + (Data.ProtoLens.Tag 2, sourceFile__field_descriptor), + (Data.ProtoLens.Tag 3, begin__field_descriptor), + (Data.ProtoLens.Tag 4, end__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _GeneratedCodeInfo'Annotation'_unknownFields + (\ x__ y__ + -> x__ {_GeneratedCodeInfo'Annotation'_unknownFields = y__}) + 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'_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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 + 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.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__) ())))) +{- | Fields : + + * 'Proto.Google.Protobuf.Descriptor_Fields.messageSetWireFormat' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'messageSetWireFormat' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.noStandardDescriptorAccessor' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'noStandardDescriptorAccessor' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.mapEntry' @:: Lens' MessageOptions Prelude.Bool@ + * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'mapEntry' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@ + * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MessageOptions [UninterpretedOption]@ + * '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'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _MessageOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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 + 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.<>) + (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'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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "name" + loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x) + 18 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "input_type" + loop + (Lens.Family2.set (Data.ProtoLens.Field.field @"inputType") y x) + 26 + -> do y <- (Data.ProtoLens.Encoding.Bytes.) + (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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.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'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _MethodOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 + 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 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'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 + 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.<>) + (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'uninterpretedOption x__) ()))) +data MethodOptions'IdempotencyLevel + = MethodOptions'IDEMPOTENCY_UNKNOWN | + MethodOptions'NO_SIDE_EFFECTS | + MethodOptions'IDEMPOTENT + deriving (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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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.uninterpretedOption' @:: Lens' OneofOptions [UninterpretedOption]@ + * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' OneofOptions (Data.Vector.Vector UninterpretedOption)@ -} +data OneofOptions + = OneofOptions'_constructor {_OneofOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _OneofOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 OneofOptions + in + Data.Map.fromList + [(Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)] + unknownFields + = Lens.Family2.Unchecked.lens + _OneofOptions'_unknownFields + (\ x__ y__ -> x__ {_OneofOptions'_unknownFields = y__}) + defMessage + = OneofOptions'_constructor + {_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 + 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.<>) + (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'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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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.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'deprecated :: !(Prelude.Maybe Prelude.Bool), + _ServiceOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption), + _ServiceOptions'_unknownFields :: !Data.ProtoLens.FieldSet} + deriving (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 "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" + 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 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 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'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 + 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'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'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 (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" + 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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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 (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" + 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 value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt + Data.ProtoLens.Encoding.Bytes.getBytes + (Prelude.fromIntegral len) + Data.ProtoLens.Encoding.Bytes.runEither + (case Data.Text.Encoding.decodeUtf8' value of + (Prelude.Left err) + -> Prelude.Left (Prelude.show err) + (Prelude.Right r) -> Prelude.Right r)) + "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__) ())) 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,1039 @@ +{- 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#-} +{-# 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" +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" +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" +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" +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" +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" +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" +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" +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" +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'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'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'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'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'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'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'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'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'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'phpGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "maybe'phpGenericServices" a) => + Lens.Family2.LensLike' f s a +maybe'phpGenericServices + = Data.ProtoLens.Field.field @"maybe'phpGenericServices" +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'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'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'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'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" +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" +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" +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" +phpGenericServices :: + forall f s a. + (Prelude.Functor f, + Data.ProtoLens.Field.HasField s "phpGenericServices" a) => + Lens.Family2.LensLike' f s a +phpGenericServices + = Data.ProtoLens.Field.field @"phpGenericServices" +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" +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" +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" +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" +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" +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" +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'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'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'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" +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 --- a/app/protoc-gen-haskell.hs +++ b/app/protoc-gen-haskell.hs @@ -4,13 +4,17 @@ -- 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 #-} {-# LANGUAGE PatternSynonyms #-} module Main where import qualified Data.ByteString as B import Data.Map.Strict ((!)) -import Data.Monoid ((<>)) +#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) @@ -24,79 +28,71 @@ ( CodeGeneratorRequest , CodeGeneratorResponse ) -import Proto.Google.Protobuf.Compiler.Plugin_Fields - ( content - , file - , fileToGenerate - , parameter - , protoFile - ) import Proto.Google.Protobuf.Descriptor (FileDescriptorProto) -import Proto.Google.Protobuf.Descriptor_Fields (name, dependency) import System.Environment (getProgName) import System.Exit (exitWith, ExitCode(..)) import System.IO as IO -import Data.ProtoLens.Compiler.Combinators - ( prettyPrint - , prettyPrintModule - , getModuleName - ) +import Data.ProtoLens.Compiler.Generate.Commented (CommentedModule, getModuleName) import Data.ProtoLens.Compiler.Generate import Data.ProtoLens.Compiler.Plugin +import DynFlags (DynFlags, getDynFlags) +import GHC (runGhc) +import GhcMonad (liftIO) +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 -> B.putStr $ encodeMessage $ makeResponse progName x + Right x -> runGhc (Just libdir) $ do + dflags <- getDynFlags + liftIO $ B.putStr $ encodeMessage $ + makeResponse dflags progName x -makeResponse :: String -> CodeGeneratorRequest -> CodeGeneratorResponse -makeResponse prog request = let - useRuntime = case T.unpack $ request ^. parameter of - "" -> reexported - "no-runtime" -> id - p -> error $ "Error reading parameter: " ++ show p - outputFiles = generateFiles useRuntime header - (request ^. protoFile) - (request ^. fileToGenerate) +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) + <> (f ^. #name) <> " by the " <> pack prog <> " program. -}\n" in defMessage - & file .~ [ defMessage - & name .~ outputName - & content .~ outputContent + & #file .~ [ defMessage + & #name .~ outputName + & #content .~ outputContent | (outputName, outputContent) <- outputFiles ] -generateFiles :: ModifyImports -> (FileDescriptorProto -> Text) +generateFiles :: DynFlags -> (FileDescriptorProto -> Text) -> [FileDescriptorProto] -> [ProtoFileName] -> [(Text, Text)] -generateFiles modifyImports header files toGenerate = let - modulePrefix = "Proto" - filesByName = analyzeProtoFiles modulePrefix files +generateFiles dflags header files toGenerate = let + filesByName = analyzeProtoFiles files -- The contents of the generated Haskell file for a given .proto file. + modulesToBuild :: ProtoFile -> [CommentedModule] modulesToBuild f = let - deps = descriptor f ^. dependency + deps = descriptor f ^. #dependency imports = Set.toAscList $ Set.fromList - [ haskellModule (filesByName ! exportName) - | dep <- deps - , exportName <- exports (filesByName ! dep) - ] + $ map (haskellModule . (filesByName !)) deps in generateModule (haskellModule f) imports - modifyImports + (publicImports f) (definitions f) (collectEnvFromDeps deps filesByName) (services f) - in [ ( outputFilePath $ prettyPrint $ getModuleName modul - , header (descriptor f) <> pack (prettyPrintModule modul) + in [ ( 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,13 +1,13 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.31.1. +-- This file has been generated from package.yaml by hpack version 0.31.2. -- -- see: https://github.com/sol/hpack -- --- hash: e145fd43ae4afd8f47db892dc65ea8f96de237631a8d9299638fbe34a9c43a5a +-- hash: b83c1bee48d610ca9d51aadc42916775c24fa81838d58cc5ebda6ce2d0797418 name: proto-lens-protoc -version: 0.5.0.0 +version: 0.6.0.0 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.' @@ -30,39 +30,44 @@ library exposed-modules: - Data.ProtoLens.Compiler.Combinators - Data.ProtoLens.Compiler.Definitions - Data.ProtoLens.Compiler.Generate - Data.ProtoLens.Compiler.Plugin + Data.ProtoLens.Compiler.ModuleName other-modules: - Data.ProtoLens.Compiler.Generate.Encoding - Data.ProtoLens.Compiler.Generate.Field Paths_proto_lens_protoc hs-source-dirs: src build-depends: - base >=4.9 && <4.13 - , containers >=0.5 && <0.7 + base >=4.9 && <4.14 , filepath >=1.4 && <1.6 - , haskell-src-exts >=1.18 && <1.22 - , lens-family ==1.2.* - , pretty ==1.1.* - , proto-lens ==0.5.* - , text ==1.2.* default-language: Haskell2010 executable proto-lens-protoc main-is: protoc-gen-haskell.hs other-modules: + Data.ProtoLens.Compiler.Definitions + Data.ProtoLens.Compiler.Generate + Data.ProtoLens.Compiler.Generate.Commented + Data.ProtoLens.Compiler.Generate.Encoding + Data.ProtoLens.Compiler.Generate.Field + Data.ProtoLens.Compiler.Plugin + 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.9 && <4.13 + base >=4.9 && <4.14 , bytestring ==0.10.* , containers >=0.5 && <0.7 - , lens-family ==1.2.* - , proto-lens ==0.5.* + , filepath >=1.4 && <1.6 + , ghc >=8.2 && <8.10 + , ghc-paths ==0.1.* + , ghc-source-gen ==0.3.* + , lens-family >=1.2 && <2.1 + , pretty ==1.1.* + , proto-lens ==0.6.* , proto-lens-protoc + , proto-lens-runtime ==0.6.* , text ==1.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,462 +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 #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE OverloadedStrings #-} --- | Some utility functions, classes and instances for nicer code generation. --- --- Re-exports simpler versions of the types and constructors from --- @haskell-src-exts@. --- --- 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 - ( module Data.ProtoLens.Compiler.Combinators - -- Since ImportDecl is a record type, for simplicity we just export it - -- directly. - , Syntax.ImportDecl(..) - ) where - -import Data.Char (isAlphaNum, isUpper) -import Data.String (IsString(..)) -import qualified Language.Haskell.Exts.Syntax as Syntax -import qualified Language.Haskell.Exts.Pretty as Pretty -import Text.PrettyPrint (($+$), (<+>), render, text, vcat, Doc) - -prettyPrint :: Pretty.Pretty a => a -> String -prettyPrint = Pretty.prettyPrint - -prettyPrim :: Pretty.Pretty a => a -> Doc -prettyPrim = Pretty.prettyPrim - -type Asst = Syntax.Asst () - -classA :: QName -> [Type] -> Asst -classA = Syntax.ClassA () - -equalP :: Type -> Type -> Asst -equalP = Syntax.EqualP () - - -type ConDecl = Syntax.ConDecl () - -conDecl :: Name -> [Type] -> ConDecl -conDecl constructorName paramTypes - = Syntax.ConDecl () constructorName $ - fmap tyBang paramTypes - -recDecl :: Name -> [(Name, Type)] -> ConDecl -recDecl dataName fields - = Syntax.RecDecl () dataName - [Syntax.FieldDecl () [n] (tyBang t) | (n,t) <- fields] - - -type Decl = Syntax.Decl () - -patSynSig :: Name -> Type -> Decl -#if MIN_VERSION_haskell_src_exts(1,21,0) -patSynSig n t = Syntax.PatSynSig () [n] Nothing Nothing Nothing Nothing t -#elif MIN_VERSION_haskell_src_exts(1,20,0) -patSynSig n t = Syntax.PatSynSig () [n] Nothing Nothing Nothing t -#else -patSynSig n t = Syntax.PatSynSig () n Nothing Nothing Nothing t -#endif - -patSyn :: Pat -> Pat -> Decl -patSyn p1 p2 = Syntax.PatSyn () p1 p2 Syntax.ImplicitBidirectional - -dataDecl :: Name -> [ConDecl] -> Deriving -> Decl -dataDecl = dataDeclHelper $ Syntax.DataType () - -newtypeDecl :: Name -> Type -> Deriving -> Decl -newtypeDecl name wrappedType - = dataDeclHelper (Syntax.NewType ()) name - [Syntax.ConDecl () name [wrappedType]] - -dataDeclHelper :: Syntax.DataOrNew () -> Name -> [ConDecl] -> Deriving -> Decl -dataDeclHelper dataOrNew name conDecls derives - = Syntax.DataDecl () dataOrNew Nothing - (Syntax.DHead () name) - [Syntax.QualConDecl () Nothing Nothing q | q <- conDecls] -#if MIN_VERSION_haskell_src_exts(1,20,0) - [derives] -#else - $ Just derives -#endif - -type Deriving = Syntax.Deriving () - -deriving' :: [QName] -> Deriving -deriving' classes = Syntax.Deriving () -#if MIN_VERSION_haskell_src_exts(1,20,0) - Nothing -#endif - [ Syntax.IRule () Nothing Nothing (Syntax.IHCon () c) - | c <- classes - ] - -funBind :: [Match] -> Decl -funBind = Syntax.FunBind () - -patBind :: Pat -> Exp -> Decl -patBind p e = Syntax.PatBind () p (Syntax.UnGuardedRhs () e) Nothing - -instType :: Type -> Type -> Syntax.InstDecl () -instType = Syntax.InsType () - -instMatch :: [Match] -> Syntax.InstDecl () -instMatch m = Syntax.InsDecl () $ funBind m - -instDeclWithTypes :: [Asst] -> InstHead -> [Syntax.InstDecl ()] -> Decl -instDeclWithTypes ctx instHead decls - = Syntax.InstDecl () Nothing - (Syntax.IRule () Nothing ctx' instHead) - $ Just decls - where - ctx' = case ctx of - [] -> Nothing - [c] -> Just $ Syntax.CxSingle () c - cs -> Just $ Syntax.CxTuple () cs - -instDecl :: [Asst] -> InstHead -> [[Match]] -> Decl -instDecl ctx instHead = instDeclWithTypes ctx instHead . fmap instMatch - -typeSig :: [Name] -> Type -> Decl -typeSig = Syntax.TypeSig () - - -type Exp = Syntax.Exp () - -let' :: [Decl] -> Exp -> Exp -let' ds e = Syntax.Let () (Syntax.BDecls () ds) e - -type Alt = Syntax.Alt () - -case' :: Exp -> [Alt] -> Exp -case' = Syntax.Case () - -(-->) :: Pat -> Exp -> Alt -p --> e = Syntax.Alt () p (Syntax.UnGuardedRhs () e) Nothing -infixl 1 --> - -stringExp :: String -> Exp -stringExp = Syntax.Lit () . string - -charExp :: Char -> Exp -charExp = Syntax.Lit () . char - -tuple :: [Exp] -> Exp -tuple = Syntax.Tuple () Syntax.Boxed - -lambda :: [Pat] -> Exp -> Exp -lambda ps e = Syntax.Paren () $ Syntax.Lambda () ps e - -(@::@) :: Exp -> Type -> Exp -(@::@) = Syntax.ExpTypeSig () -infixl 2 @::@ - -recConstr :: QName -> [FieldUpdate] -> Exp -recConstr = Syntax.RecConstr () - -recUpdate :: Exp -> [FieldUpdate] -> Exp -recUpdate = Syntax.RecUpdate () - -var, con :: QName -> Exp -var = Syntax.Var () -con = Syntax.Con () - -list :: [Exp] -> Exp -list = Syntax.List () - -if' :: Exp -> Exp -> Exp -> Exp -if' = Syntax.If () - --- | The ":" constructor. -cons :: Exp -cons = var $ Syntax.Special () $ Syntax.Cons () - --- | The "[]" constructor. -emptyList :: Exp -emptyList = var $ Syntax.Special () $ Syntax.ListCon () - --- | The "()" constructor. -unit :: Exp -unit = var $ Syntax.Special () $ Syntax.UnitCon () - -typeApp :: Type -> Exp -typeApp = Syntax.TypeApp () - -type Stmt = Syntax.Stmt () - -do' :: [Stmt] -> Exp -do' = Syntax.Do () - -(<--) :: Pat -> Exp -> Stmt -(<--) = Syntax.Generator () -infixl 1 <-- - -stmt :: Exp -> Stmt -stmt = Syntax.Qualifier () - -letStmt :: [Decl] -> Stmt -letStmt = Syntax.LetStmt () . Syntax.BDecls () - -type FieldUpdate = Syntax.FieldUpdate () - -fieldUpdate :: QName -> Exp -> FieldUpdate -fieldUpdate = Syntax.FieldUpdate () - -type InstHead = Syntax.InstHead () - -ihApp :: InstHead -> [Type] -> InstHead -ihApp = foldl (Syntax.IHApp ()) - -tyParen :: Type -> Type -tyParen = Syntax.TyParen () - -tyFun :: Type -> Type -> Type -tyFun = Syntax.TyFun () - -type Match = Syntax.Match () - --- | A simple clause of a function binding. -match :: Name -> [Pat] -> Exp -> Match -match n ps e = Syntax.Match () n ps (Syntax.UnGuardedRhs () e) Nothing - -guardedMatch :: Name -> [Pat] -> [(Exp, Exp)] -> Match -guardedMatch n ps gs = - Syntax.Match () n ps - (Syntax.GuardedRhss () - $ map (\g -> Syntax.GuardedRhs () [Syntax.Qualifier () $ fst g] - (snd g)) gs) - Nothing - --- | A hand-rolled type for modules, which allows comments on top-level --- declarations. -data Module = Module ModuleName (Maybe [ExportSpec]) [ModulePragma] - [Syntax.ImportDecl ()] - [CommentedDecl] - --- | A declaration, along with an optional comment. -data CommentedDecl = CommentedDecl (Maybe String) Decl - -uncommented :: Decl -> CommentedDecl -uncommented = CommentedDecl Nothing - -commented :: String -> Decl -> CommentedDecl -commented = CommentedDecl . Just - -prettyPrintModule :: Module -> String -prettyPrintModule (Module modName exports pragmas imports decls) = - render $ - vcat (map prettyPrim pragmas) - $+$ prettyPrim (Syntax.ModuleHead () modName - -- no warning text - Nothing - (Syntax.ExportSpecList () <$> exports)) - $+$ vcat (map prettyPrim imports) - $+$ "" - $+$ vcat (map pprintDecl decls) - where - pprintDecl (CommentedDecl Nothing d) = prettyPrim d - pprintDecl (CommentedDecl (Just c) d) - = "{- |" <+> text c <+> "-}" $+$ prettyPrim d - -type ExportSpec = Syntax.ExportSpec () - -getModuleName :: Module -> ModuleName -getModuleName (Module name _ _ _ _) = name - -type ModuleName = Syntax.ModuleName () -type ModulePragma = Syntax.ModulePragma () - -languagePragma :: [Name] -> ModulePragma -languagePragma = Syntax.LanguagePragma () - -optionsGhcPragma :: String -> ModulePragma -optionsGhcPragma = Syntax.OptionsPragma () (Just Syntax.GHC) - -exportVar :: QName -> ExportSpec -exportVar = Syntax.EVar () - -exportAll :: QName -> ExportSpec -exportAll q = Syntax.EThingWith () (Syntax.EWildcard () 0) q [] - -exportWith :: QName -> [Name] -> ExportSpec -exportWith q = Syntax.EThingWith () - (Syntax.NoWildcard ()) - q - . map (Syntax.ConName ()) - -type Name = Syntax.Name () - -type Pat = Syntax.Pat () - -pApp :: QName -> [Pat] -> Pat -pApp = Syntax.PApp () - -pVar :: Name -> Pat -pVar = Syntax.PVar () - -pWildCard :: Pat -pWildCard = Syntax.PWildCard () - -stringPat :: String -> Pat -stringPat = Syntax.PLit () (Syntax.Signless ()) . string - -bangPat :: Pat -> Pat -bangPat = Syntax.PBangPat () - -patTypeSig :: Pat -> Type -> Pat -patTypeSig = Syntax.PatTypeSig () - -type QName = Syntax.QName () - -qual :: ModuleName -> Name -> QName -qual = Syntax.Qual () - -unQual :: Name -> QName -unQual = Syntax.UnQual () - - -type TyVarBind = Syntax.TyVarBind () -type Type = Syntax.Type () - -tyCon :: QName -> Type -tyCon = Syntax.TyCon () - -tyList :: Type -> Type -tyList = Syntax.TyList () - -tyPromotedList :: [Type] -> Type -tyPromotedList ts = Syntax.TyPromoted () $ Syntax.PromotedList () True ts - -tyPromotedString :: String -> Type -tyPromotedString s = Syntax.TyPromoted () $ Syntax.PromotedString () s s - -type Promoted = Syntax.Promoted () - -tyPromotedCon :: Promoted -> Type -tyPromotedCon = Syntax.TyPromoted () - -instance IsString Promoted where - fromString = Syntax.PromotedCon () True . fromString - -tyForAll :: [TyVarBind] -> [Asst] -> Type -> Type -tyForAll vars ctx t = Syntax.TyForall () (Just vars) - (Just $ Syntax.CxTuple () ctx) - t - -tyBang :: Type -> Type -tyBang = Syntax.TyBang () (Syntax.BangedTy ()) (Syntax.NoUnpackPragma ()) - -tyWildCard :: Type -tyWildCard = Syntax.TyWildCard () Nothing - --- | 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 - (@@) = Syntax.TyApp () - -instance App Exp where - Syntax.App () (Syntax.Con () v) x @@ y - -- For readability, print fully-applied operators infix, i.e., "x OP y" - -- rather than "(OP) x y". - | isSymbol v - = Syntax.InfixApp () (Syntax.Paren () x) (Syntax.QVarOp () v) y - where - isSymbol (Syntax.Qual () _ (Syntax.Symbol () _)) = True - isSymbol (Syntax.UnQual () (Syntax.Symbol () _)) = True - isSymbol _ = False - x @@ y = Syntax.App () x y - -instance IsString Name where - fromString s - -- TODO: better handle the case of mixed ident and symbol characters. - | all isIdentChar s = Syntax.Ident () s - | otherwise = Syntax.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` ("_'" :: String) - -instance IsString ModuleName where - fromString = Syntax.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) - = Syntax.Qual () (fromString $ reverse f'') (fromString $ reverse f') - | otherwise = Syntax.UnQual () $ fromString f - -instance IsString Type where - fromString fs@(f:_) - | isUpper f = Syntax.TyCon () $ fromString fs - fromString fs = Syntax.TyVar () $ fromString fs - -instance IsString Exp where - fromString fs@(f:_) - -- TODO: this logic isn't correct for qualified names (since the module is - -- capitalized). However, it doesn't matter in practice if we're just - -- generating code. - | isUpper f = Syntax.Con () $ fromString fs - fromString fs = Syntax.Var () $ fromString fs - -instance IsString Pat where - fromString = Syntax.PVar () . fromString - -instance IsString TyVarBind where - fromString = Syntax.UnkindedVar () . fromString - -instance IsString InstHead where - fromString = Syntax.IHCon () . 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 = Syntax.Lit () $ Syntax.Int () n (show n) - | otherwise = Syntax.NegApp () $ litInt $ negate n - -litFrac :: Rational -> Exp -litFrac x - | x >= 0 = Syntax.Lit () $ Syntax.Frac () x (show x) - | otherwise = Syntax.NegApp () $ litFrac $ negate x - -pLitInt :: Integer -> Pat -pLitInt n = Syntax.PLit () sign $ Syntax.Int () n' (show n') - where - (n', sign) - | n >= 0 = (n, Syntax.Signless ()) - | otherwise = (negate n, Syntax.Negative ()) - -string :: String -> Syntax.Literal () -string s = Syntax.String () s (show s) - -char :: Char -> Syntax.Literal () -char c = Syntax.Char () c [c] - -modifyModuleName :: (String -> String) -> ModuleName -> ModuleName -modifyModuleName f (Syntax.ModuleName _ unpacked) = - Syntax.ModuleName () $ f unpacked - 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,650 +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 CPP #-} -{-# LANGUAGE DeriveFunctor #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# 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 Control.Applicative (liftA2) -import Data.Char (isUpper, toUpper) -import Data.Int (Int32) -import Data.List (mapAccumL) -import qualified Data.Map as Map -import Data.Maybe (fromMaybe) -#if !MIN_VERSION_base(4,11,0) -import Data.Monoid ((<>)) -#endif -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 - , EnumDescriptorProto - , EnumValueDescriptorProto - , FieldDescriptorProto - , FieldDescriptorProto'Label(..) - , FieldDescriptorProto'Type(..) - , FileDescriptorProto - , MethodDescriptorProto - , ServiceDescriptorProto - ) -import Proto.Google.Protobuf.Descriptor_Fields - ( clientStreaming - , enumType - , field - , inputType - , label - , mapEntry - , maybe'oneofIndex - , maybe'packed - , messageType - , method - , name - , nestedType - , number - , oneofDecl - , options - , outputType - , package - , serverStreaming - , service - , syntax - , type' - , typeName - , value - ) - -import Data.ProtoLens.Compiler.Combinators - ( Name - , QName - , ModuleName - , Type - , qual - , tyPromotedString - , 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) 'QName' (when talking about definitions --- either from this or another file). -type Env n = Map.Map Text (Definition n) - -data SyntaxType = Proto2 | Proto3 - deriving (Show, 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 - -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 :: [PlainFieldInfo] -- ^ Fields not belonging to a oneof. - , messageOneofFields :: [OneofInfo] - -- ^ The oneofs in this message, associated with the fields that - -- belong to them. - , messageUnknownFields :: Name - -- ^ 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] - } - -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 optional 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, - -- 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 :: Name - -- ^ 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 :: Name - -- ^ The constructor for building a 'oneofTypeName' from the - -- value in this field. - , casePrismName :: Name - -- ^ 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 :: Name - -- ^ 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 :: Name - -- ^ 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 -> Name -nameFromSymbol (Symbol s) = fromString s - --- | Construct a promoted, type-level string. -promoteSymbol :: Symbol -> Type -promoteSymbol (Symbol s) = tyPromotedString 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 :: Name - , unrecognizedValueName :: Name - } - --- | 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 Haskell name for the type of a given field (message or enum). -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." - --- | Look up the Haskell name for the type of a given type. -definedType :: Text -> Env QName -> Definition QName -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 -> Env Name -collectDefinitions fd = let - protoPrefix = case fd ^. package of - "" -> "." - p -> "." <> p <> "." - hsPrefix = "" - in Map.fromList $ concatMap flatten $ - messageAndEnumDefs (fileSyntaxType fd) - 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 - } - - 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 :: - SyntaxType -> Text -> String - -> GroupMap - -- ^ Group fields of the parent message (if any). - -> [DescriptorProto] - -> [EnumDescriptorProto] - -> Forest (Text, Definition Name) - -- ^ Organized as a list of trees, to make it possible for callers - -- to get the immediate child nested types. -messageAndEnumDefs syntaxType protoPrefix hsPrefix groups messages enums - = map (messageDefs syntaxType protoPrefix hsPrefix groups) messages - ++ map - (flip Node [] -- Enums have no sub-definitions - . enumDef syntaxType protoPrefix hsPrefix) - enums - --- | Generate the definitions for a message and its nested types (if any). -messageDefs :: SyntaxType -> Text -> String -> GroupMap -> DescriptorProto - -> Tree (Text, Definition Name) -messageDefs syntaxType 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) - , messageDescriptor = d - , messageFields = - map (liftA2 PlainFieldInfo - (fieldKind syntaxType mapEntries) (fieldInfo hsPrefix')) - $ Map.findWithDefault [] Nothing allFields - , messageOneofFields = collectOneofFields hsPrefix' d allFields - , messageUnknownFields = - fromString $ "_" ++ hsPrefix' ++ "_unknownFields" - , groupFieldNumber = Map.lookup protoName groups - } - subDefs = messageAndEnumDefs - syntaxType - (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 - --- | If this type is a map entry, retrieves the relevant information --- along with the proto name of this type. -mapEntryInfo :: Definition Name -> 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 Name)] -> 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 - ] - -fieldInfo :: String -> FieldDescriptorProto -> FieldInfo -fieldInfo hsPrefix f = FieldInfo - { fieldDescriptor = f - , fieldName = mkFieldName hsPrefix $ f ^. name - } - -fieldKind :: - SyntaxType -> Map.Map Text MapEntryInfo -> FieldDescriptorProto - -> FieldKind -fieldKind syntaxType mapEntries f = case f ^. label of - FieldDescriptorProto'LABEL_OPTIONAL - | syntaxType == Proto3 - && f ^. type' /= FieldDescriptorProto'TYPE_MESSAGE - -> OptionalValueField - | otherwise -> OptionalMaybeField - 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 - -- If the "packed" attribute isn't set, then default to packed if proto3. - -- Unfortunately, protoc doesn't implement this logic for us automatically. - packedByDefault = fromMaybe (syntaxType == Proto3) - $ f ^. options . maybe'packed - unpackableTypes = - [ FieldDescriptorProto'TYPE_MESSAGE - , FieldDescriptorProto'TYPE_GROUP - , FieldDescriptorProto'TYPE_STRING - , FieldDescriptorProto'TYPE_BYTES - ] - -collectOneofFields - :: String -> DescriptorProto -> Map.Map (Maybe Int32) [FieldDescriptorProto] - -> [OneofInfo] -collectOneofFields hsPrefix d allFields - = zipWith oneofInfo [0..] $ d ^.. oneofDecl . traverse . name - where - oneofInfo idx n = OneofInfo - { oneofFieldName = mkFieldName hsPrefix n - , oneofTypeName = fromString $ hsPrefix ++ hsNameUnique subdefTypes n - , oneofCases = map oneofCase - $ Map.findWithDefault [] (Just idx) - allFields - } - 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.) -groupFieldsByOneofIndex - :: [FieldDescriptorProto] -> Map.Map (Maybe Int32) [FieldDescriptorProto] -groupFieldsByOneofIndex = - fmap reverse - . Map.fromListWith (++) - . fmap (\f -> (f ^. maybe'oneofIndex, [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", "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 :: SyntaxType -> Text -> String -> EnumDescriptorProto - -> (Text, Definition Name) -enumDef syntaxType protoPrefix hsPrefix d = let - mkText n = protoPrefix <> n - mkHsName n = fromString $ hsPrefix ++ case hsName n of - ('_':xs) -> 'X':xs - xs -> xs - in (mkText (d ^. name) - , Enum EnumInfo - { enumName = mkHsName (d ^. name) - , enumUnrecognized = if syntaxType == Proto2 - then Nothing - else Just EnumUnrecognizedInfo - { unrecognizedName - = mkHsName (d ^. name <> "'Unrecognized") - , unrecognizedValueName - = mkHsName (d ^. name <> "'UnrecognizedValue") - } - , 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 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. --- 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 - -overloadedFieldName :: FieldInfo -> Symbol -overloadedFieldName = overloadedName . fieldName 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,1030 +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 LambdaCase #-} -{-# LANGUAGE OverloadedStrings #-} -module Data.ProtoLens.Compiler.Generate( - generateModule, - ModifyImports, - reexported, - ) 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) -import Data.Monoid ((<>)) -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 Lens.Family2 ((^.)) -import Text.Printf (printf) - -import Proto.Google.Protobuf.Descriptor - ( EnumValueDescriptorProto - , FieldDescriptorProto - , FieldDescriptorProto'Type(..) - ) -import Proto.Google.Protobuf.Descriptor_Fields - ( defaultValue - , name - , number - , type' - , typeName - ) - -import Data.ProtoLens.Compiler.Combinators -import Data.ProtoLens.Compiler.Definitions -import Data.ProtoLens.Compiler.Generate.Encoding -import Data.ProtoLens.Compiler.Generate.Field - ( hsFieldType - , hsFieldVectorType - ) - --- 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 :: ModuleName - -> [ModuleName] -- ^ The imported modules - -> ModifyImports - -> Env Name -- ^ Definitions in this file - -> Env QName -- ^ Definitions in the imported modules - -> [ServiceInfo] - -> [Module] -generateModule modName imports modifyImport definitions importedEnv services - = [ Module modName - (Just $ (serviceExports ++) $ concatMap generateExports $ Map.elems definitions) - pragmas - (mainImports ++ sharedImports) - $ (concatMap generateDecls $ Map.toList definitions) - ++ map uncommented (concatMap (generateServiceDecls env) services) - , Module fieldModName - Nothing - pragmas - sharedImports - . map uncommented - $ concatMap generateFieldDecls allLensNames - ] - where - fieldModName = modifyModuleName (++ "_Fields") modName - pragmas = - [ languagePragma $ map fromString - ["ScopedTypeVariables", "DataKinds", "TypeFamilies", - "UndecidableInstances", "GeneralizedNewtypeDeriving", - "MultiParamTypeClasses", "FlexibleContexts", "FlexibleInstances", - "PatternSynonyms", "MagicHash", "NoImplicitPrelude", - "DataKinds", "BangPatterns", "TypeApplications"] - -- Allow unused imports in case we don't import anything from - -- Data.Text, Data.Int, etc. - , optionsGhcPragma "-fno-warn-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 "-fno-warn-duplicate-exports" - ] - mainImports = map (modifyImport . importSimple) - [ "Control.DeepSeq", "Data.ProtoLens.Prism" ] - sharedImports = map (modifyImport . importSimple) - [ "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" - ] - ++ map importSimple imports - 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 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 QName -> MessageInfo Name -> [RecordField] -allMessageFields env info = - map (plainRecordField env) (messageFields info) - ++ map (oneofRecordField env) (messageOneofFields info) - -importSimple :: ModuleName -> ImportDecl () -importSimple m = ImportDecl - { importAnn = () - , 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} - = imp { importAs = Just m, importModule = m' } - where - m' = fromString $ "Data.ProtoLens.Runtime." ++ prettyPrint m - -messageComment :: ModuleName -> Name -> [RecordField] -> String -messageComment fieldModName n fields = unlines - $ ["Fields :", ""] - ++ map item (concatMap recordFieldLenses fields) - where - item :: LensInstance -> String - item l = (printf " * '%s.%s' @:: %s@" - (prettyPrint fieldModName) - (prettyPrint $ nameFromSymbol $ lensSymbol l) - (prettyPrint $ "Lens'" @@ t @@ (lensFieldType l))) - t = tyCon (unQual n) - -generateMessageExports :: MessageInfo Name -> [ExportSpec] -generateMessageExports m = - -- Hide the message contructor, but expose "oneof" case constructors. - exportWith (unQual $ messageName m) [] - : map (exportAll . unQual . oneofTypeName) - (messageOneofFields m) - -generateServiceDecls :: Env QName -> ServiceInfo -> [Decl] -generateServiceDecls env si = - -- data MyService = MyService - [ dataDecl serverDataName - [ recDecl serverDataName [] - ] - $ deriving' [] - ] ++ - -- instance Data.ProtoLens.Service.Types.Service MyService where - -- type ServiceName MyService = "myService" - -- type ServicePackage MyService = "some.package" - -- type ServiceMethods MyService = '["normalMethod", "streamingMethod"] - [ instDeclWithTypes [] ("Data.ProtoLens.Service.Types.Service" `ihApp` [serverRecordType]) - [ instType ("ServiceName" @@ serverRecordType) - . tyPromotedString . T.unpack $ serviceName si - , instType ("ServicePackage" @@ serverRecordType) - . tyPromotedString . T.unpack $ servicePackage si - , instType ("ServiceMethods" @@ serverRecordType) - $ tyPromotedList - [ tyPromotedString . T.unpack $ methodIdent m - | m <- List.sortBy (comparing methodIdent) $ serviceMethods si - ] - ] - ] ++ - -- 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 - [ instDeclWithTypes [] ("Data.ProtoLens.Service.Types.HasMethodImpl" `ihApp` [serverRecordType, instanceHead]) - [ instType ("MethodName" @@ serverRecordType @@ instanceHead) - . tyPromotedString . T.unpack $ methodName m - , instType ("MethodInput" @@ serverRecordType @@ instanceHead) - . lookupType $ methodInput m - , instType ("MethodOutput" @@ serverRecordType @@ instanceHead) - . lookupType $ methodOutput m - , instType ("MethodStreamingType" @@ serverRecordType @@ instanceHead) - . tyPromotedCon - $ 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 = tyPromotedString (T.unpack $ methodIdent m) - ] - where - serverDataName = fromString . T.unpack $ serviceName si - serverRecordType = tyCon $ unQual serverDataName - - lookupType t = case definedType t env of - Message msg -> tyCon $ messageName msg - Enum _ -> error "Service must have a message type" - - -generateMessageDecls :: ModuleName -> Env QName -> T.Text -> MessageInfo Name -> [CommentedDecl] -generateMessageDecls fieldModName env protoName info = - -- data Bar = Bar { - -- foo :: Baz - -- } - [ commented (messageComment fieldModName (messageName info) allFields) - $ dataDecl dataName - [recDecl dataName $ - [ (recordFieldName f, recordFieldType f) - | f <- allFields - ] - ++ [(messageUnknownFields info, "Data.ProtoLens.FieldSet")] - ] - $ deriving' ["Prelude.Eq", "Prelude.Ord"] - -- instance Show Bar where - -- showsPrec __x __s = showChar '{' (showString (showMessageShort __x) (showChar '}' s)) - , uncommented $ - instDecl [] ("Prelude.Show" `ihApp` [dataType]) - [[match "showsPrec" ["_", "__x", "__s"] - $ "Prelude.showChar" @@ charExp '{' - @@ ("Prelude.showString" @@ ("Data.ProtoLens.showMessageShort" @@ "__x") - @@ ("Prelude.showChar" @@ charExp '}' @@ "__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 $ dataDecl (oneofTypeName oneofInfo) - [ conDecl consName [hsFieldType env f] - | c <- oneofCases oneofInfo - , let f = caseField c - , let consName = caseConstructorName c - ] - $ deriving' ["Prelude.Show", "Prelude.Eq", "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 $ instDecl [] - ("Data.ProtoLens.Field.HasField" `ihApp` - [dataType, sym, tyParen t]) - [[match "fieldOf" [pWildCard] $ - "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 $ instDecl [] ("Data.ProtoLens.Message" `ihApp` [dataType]) - $ messageInstance env protoName info - -- instance NFData Bar where - , uncommented $ instDecl [] ("Control.DeepSeq.NFData" `ihApp` [dataType]) - [[match "rnf" [] $ messageRnfExpr info]] - ] ++ - -- instance NFData Foo'Bar where - [ uncommented $ - instDecl [] ("Control.DeepSeq.NFData" `ihApp` - [tyCon $ unQual $ oneofTypeName o]) - [map oneofRnfMatch $ oneofCases o] - | o <- messageOneofFields info - ] - where - dataType = tyCon $ 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 QName -> OneofInfo -> [Decl] -generatePrisms env oneofInfo = - if length cases > 1 - then concatMap (generatePrism altOtherwise) cases - else concatMap (generatePrism mempty) cases - where - cases = oneofCases oneofInfo - altOtherwise = [ "_otherwise" --> "Prelude.Nothing" ] - - -- Generate type signature - -- e.g. Prism' Bar'C Float - generateTypeSig f funName = - typeSig [funName] $ "Data.ProtoLens.Prism.Prism'" - -- The oneof sum type name - @@ (tyCon . 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 otherwiseCase consName = - "Data.ProtoLens.Prism.prism'" - -- Sum type constructor - @@ con (unQual consName) - -- Case deconstruction - @@ (lambda ["p__"] $ - case' "p__" $ - [ pApp (unQual consName) ["p__val"] - --> "Prelude.Just" @@ "p__val" - ] - -- We want to generate the otherwise case - -- depending on the amount of sum type cases there are - ++ otherwiseCase - ) - generatePrism :: [Alt] -> OneofCase -> [Decl] - generatePrism otherwiseCase oneofCase = - let consName = caseConstructorName oneofCase - prismName = casePrismName oneofCase - in [ generateTypeSig (caseField oneofCase) prismName - , funBind [ match prismName [] $ generateFunDef otherwiseCase consName ] - ] - -generatePrismExports :: OneofInfo -> [ExportSpec] -generatePrismExports = map (exportVar . unQual . casePrismName) . oneofCases - -generateEnumExports :: EnumInfo Name -> [ExportSpec] -generateEnumExports e = [exportAll n, exportWith 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 -> [exportVar . unQual $ unrecognizedValueName u] - Nothing -> [] - -generateServiceExports :: ServiceInfo -> ExportSpec -generateServiceExports si = exportAll $ unQual $ fromString $ T.unpack $ serviceName si - -generateEnumDecls :: EnumInfo Name -> [Decl] -generateEnumDecls info = - -- Proto3-only: - -- newtype FooEnum'UnrecognizedValue = FooEnum'UnrecognizedValue Data.Int.Int32 - -- deriving (Prelude.Eq, Prelude.Ord, Prelude.Show, Prelude.Read) - [ newtypeDecl (unrecognizedValueName u) - "Data.Int.Int32" - $ deriving' ["Prelude.Eq", "Prelude.Ord", "Prelude.Show"] - | Just u <- [unrecognized] - ] - ++ - - -- data FooEnum - -- = Enum1 - -- | Enum2 - -- | FooEnum'Unrecognized !FooEnum'UnrecognizedValue - -- deriving (Prelude.Show, Prelude.Eq, Prelude.Ord, Prelude.Read) - [ dataDecl dataName - ( (flip conDecl [] <$> constructorNames) - ++ [ conDecl (unrecognizedName u) [tyCon $ unQual (unrecognizedValueName u)] - | Just u <- [unrecognized] - ] - ) - $ deriving' ["Prelude.Show", "Prelude.Eq", "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 - , instDecl [] ("Data.ProtoLens.MessageEnum" `ihApp` [dataType]) - [ [ match "maybeToEnum" [pLitInt k] $ "Prelude.Just" @@ con (unQual c) - | (c, k) <- constructorNumbers - ] - ++ - [ case enumUnrecognized info of - Nothing -> match "maybeToEnum" [pWildCard] "Prelude.Nothing" - Just u -> match "maybeToEnum" ["k"] - $ "Prelude.Just" @@ - (con (unQual $ unrecognizedName u) - @@ (con (unQual $ unrecognizedValueName u) - @@ ("Prelude.fromIntegral" @@ "k") - ) - ) - ] - , [ match "showEnum" [pApp (unQual n) []] - $ stringExp pn - | v <- filter (null . enumAliasOf) $ enumValues info - , let n = enumValueName v - , let pn = T.unpack $ enumValueDescriptor v ^. name - ] ++ - [ match "showEnum" [pApp (unQual $ unrecognizedName u) - [pApp (unQual $ unrecognizedValueName u) [pVar "k"]] - ] - $ "Prelude.show" @@ "k" - | Just u <- [unrecognized] - ] - , [ guardedMatch "readEnum" [pVar "k"] - [ ("Prelude.==" @@ "k" @@ stringExp pn, "Prelude.Just" @@ con (unQual n)) - | v <- enumValues info - , let n = enumValueName v - , let pn = T.unpack $ enumValueDescriptor v ^. name - ] - , match "readEnum" [pVar "k"] $ "Prelude.>>=" - @@ ("Text.Read.readMaybe" @@ "k") - @@ "Data.ProtoLens.maybeToEnum"] - ] - - -- instance Bounded Foo where - -- minBound = Foo1 - -- maxBound = FooN - , instDecl [] ("Prelude.Bounded" `ihApp` [dataType]) - [[ match "minBound" [] $ con $ unQual minBoundName - , match "maxBound" [] $ con $ 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 - , instDecl [] ("Prelude.Enum" `ihApp` [dataType]) - [[match "toEnum" ["k__"] - $ "Prelude.maybe" @@ errorMessageExpr @@ "Prelude.id" - @@ ("Data.ProtoLens.maybeToEnum" @@ "k__")] - , [ match "fromEnum" [pApp (unQual c) []] $ litInt k - | (c, k) <- constructorNumbers - ] - ++ - [ match "fromEnum" [pApp (unQual $ unrecognizedName u) - [pApp (unQual $ unrecognizedValueName u) [pVar "k"]] - ] - $ "Prelude.fromIntegral" @@ "k" - | Just u <- [unrecognized] - ] - , 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 Data.ProtoLens.FieldDefault Foo where - -- fieldDefault = FirstEnumValue - , instDecl [] ("Data.ProtoLens.FieldDefault" `ihApp` [dataType]) - [[match "fieldDefault" [] defaultCon]] - - -- instance NFData Foo where - -- rnf x__ = seq x__ () - -- (Trivial since enum types are already strict) - , instDecl [] ("Control.DeepSeq.NFData" `ihApp` [dataType]) - [[ match "rnf" ["x__"] $ "Prelude.seq" @@ "x__" @@ "()" ]] - ] ++ - - -- pattern Enum2a :: FooEnum - -- pattern Enum2a = Enum2 - concat - [ [ patSynSig aliasName dataType - , patSyn (pVar aliasName) (pVar 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 = "Prelude.error" - @@ ("Prelude.++" @@ stringExp errorMessage - @@ ("Prelude.show" @@ "k__")) - alias funName implName = [match funName [] implName] - - dataType = tyCon $ unQual dataName - - constructors :: [(Name, EnumValueDescriptorProto)] - constructors = List.sortBy (comparing ((^. number) . snd)) - [(n, d) | EnumValueInfo - { enumValueName = n - , enumValueDescriptor = d - , enumAliasOf = Nothing - } <- enumValues info - ] - constructorNames = map fst constructors - - defaultCon = con $ unQual $ head constructorNames - - minBoundName = head constructorNames - maxBoundName = last constructorNames - - constructorNumbers = map (second (fromIntegral . (^. number))) constructors - - succPairs = zip constructorNames $ tail constructorNames - succDecl funName boundName thePairs = - match funName [pApp (unQual boundName) []] - ("Prelude.error" @@ stringExp (concat - [ prettyPrint dataName, ".", prettyPrint funName, ": bad argument " - , prettyPrint boundName, ". This value would be out of bounds." - ])) - : - [ match funName [pApp (unQual from) []] $ con $ unQual to - | (from, to) <- thePairs - ] - ++ - [ match funName [pApp (unQual $ unrecognizedName u) [pWildCard]] - ("Prelude.error" @@ stringExp (concat - [ prettyPrint dataName, ".", prettyPrint funName, ": bad argument: unrecognized value" - ])) - | Just u <- [unrecognized] - ] - -generateFieldDecls :: Symbol -> [Decl] -generateFieldDecls xStr = - -- foo :: forall f s a - -- . (Functor f, HasLens s x a) => LensLike' f s a - -- foo = fieldOf @s - [ typeSig [x] - $ tyForAll ["f", "s", "a"] - [classA "Prelude.Functor" ["f"], - classA "Data.ProtoLens.Field.HasField" ["s", xSym, "a"]] - $ "Lens.Family2.LensLike'" @@ "f" @@ "s" @@ "a" - , funBind [match 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 :: Name -- ^ The Haskell name of this field (unique - -- within the module). - , recordFieldType :: Type -- ^ 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 :: Type - -- ^ The type pointed to from this lens. - , lensExp :: Exp - -- ^ 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 QName -> 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 = "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 = "Prelude.Maybe" @@ baseType - listType = tyList baseType - vectorType = hsFieldVectorType f @@ baseType - rawAccessor = "Prelude.id" - maybeAccessor = "Data.ProtoLens.maybeLens" - @@ hsFieldValueDefault env fd - -vectorAccessor :: Exp -vectorAccessor = "Lens.Family2.Unchecked.lens" @@ getter @@ setter - where - getter = "Data.Vector.Generic.toList" - setter = lambda ["_", "y__"] - $ "Data.Vector.Generic.fromList" @@ "y__" - -oneofRecordField :: Env QName -> OneofInfo -> RecordField -oneofRecordField env oneofInfo - = RecordField - { recordFieldName = haskellRecordFieldName $ oneofFieldName oneofInfo - , recordFieldType = - "Prelude.Maybe" @@ tyCon (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 = - "Prelude.Maybe" @@ tyCon (unQual $ oneofTypeName oneofInfo) - , lensExp = "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 = "Prelude.Maybe" @@ baseType - , lensExp = oneofFieldAccessor c - } - , LensInstance - { lensSymbol = baseName - , lensFieldType = baseType - , lensExp = "Prelude.." - @@ oneofFieldAccessor c - @@ ("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 QName -> PlainFieldInfo -> Exp -hsFieldDefault env f = case plainFieldKind f of - RequiredField -> hsFieldValueDefault env fd - OptionalValueField -> hsFieldValueDefault env fd - OptionalMaybeField -> "Prelude.Nothing" - MapField {} -> "Data.Map.empty" - RepeatedField {} -> "Data.Vector.Generic.empty" - where - fd = fieldDescriptor (plainFieldInfo f) - -hsFieldValueDefault :: Env QName -> FieldDescriptorProto -> Exp -hsFieldValueDefault env fd = case fd ^. type' of - FieldDescriptorProto'TYPE_MESSAGE -> "Data.ProtoLens.defMessage" - FieldDescriptorProto'TYPE_GROUP -> "Data.ProtoLens.defMessage" - FieldDescriptorProto'TYPE_ENUM - | T.null def -> "Data.ProtoLens.fieldDefault" - | 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" @@ stringExp (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 ["x__", "y__"] - $ recUpdate "x__" [fieldUpdate f "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 -> Exp -oneofFieldAccessor o - = "Lens.Family2.Unchecked.lens" @@ getter @@ setter - where - consName = caseConstructorName o - getter = lambda ["x__"] $ - case' "x__" - [ pApp "Prelude.Just" [pApp (unQual consName) ["x__val"]] - --> "Prelude.Just" @@ "x__val" - , "_otherwise" --> "Prelude.Nothing" - ] - setter = lambda ["_", "y__"] - $ "Prelude.fmap" @@ con (unQual consName) @@ "y__" - -messageInstance :: Env QName -> T.Text -> MessageInfo Name -> [[Match]] -messageInstance env protoName m = - [ [ match "messageName" [pWildCard] $ - "Data.Text.pack" @@ stringExp (T.unpack protoName)] - , [ match "fieldsByTag" [] $ - let' (map (fieldDescriptorVarBind $ messageName m) $ fields) - $ "Data.Map.fromList" @@ list fieldsByTag ] - , [ match "unknownFields" [] $ rawFieldAccessor (unQual $ messageUnknownFields m) ] - , [ match "defMessage" [] - $ recConstr (unQual $ messageName m) $ - [ fieldUpdate (unQual $ haskellRecordFieldName - $ fieldName $ plainFieldInfo f) - (hsFieldDefault env f) - | f <- messageFields m - ] ++ - [ fieldUpdate (unQual $ haskellRecordFieldName $ oneofFieldName o) - "Prelude.Nothing" - | o <- messageOneofFields m - ] ++ - [ fieldUpdate (unQual $ messageUnknownFields m) - "[]"] - ] - , [ match "parseMessage" [] $ generatedParser env m ] - , [ match "buildMessage" [] $ generatedBuilder m ] - ] - where - fieldsByTag = - [tuple - [ t, fieldDescriptorVar f ] - | f <- fields - , let t = "Data.ProtoLens.Tag" - @@ litInt (fromIntegral - $ fieldDescriptor (plainFieldInfo f) ^. number) - ] - fieldDescriptorVar = var . unQual . fieldDescriptorName - fieldDescriptorName f - = nameFromSymbol $ overloadedName (fieldName . plainFieldInfo $ f) - <> "__field_descriptor" - fieldDescriptorVarBind n f - = funBind - [match (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. - 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 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 :: Env QName -> Name -> PlainFieldInfo - -> Exp -fieldDescriptorExpr env n f = - ("Data.ProtoLens.FieldDescriptor" - -- Record the original .proto name for text format - @@ stringExp (T.unpack $ textFormatFieldName env fd) - -- Force the type signature since it can't be inferred for Map entry - -- types. - @@ (fieldTypeDescriptorExpr (fd ^. type') - @::@ - ("Data.ProtoLens.FieldTypeDescriptor" - @@ hsFieldType env (plainFieldInfo f))) - @@ fieldAccessorExpr f) - -- TODO: why is this type sig needed? - @::@ - ("Data.ProtoLens.FieldDescriptor" @@ tyCon (unQual n)) - where - fd = fieldDescriptor $ plainFieldInfo f - -fieldAccessorExpr :: PlainFieldInfo -> Exp --- (PlainField Required foo), (OptionalField foo), etc... -fieldAccessorExpr (PlainFieldInfo kind f) = accessorCon @@ fieldOfExp hsFieldName - - where - accessorCon = case kind of - RequiredField - -> "Data.ProtoLens.PlainField" @@ "Data.ProtoLens.Required" - OptionalValueField - -> "Data.ProtoLens.PlainField" @@ "Data.ProtoLens.Optional" - OptionalMaybeField - -> "Data.ProtoLens.OptionalField" - MapField entry - -> "Data.ProtoLens.MapField" - @@ fieldOfExp (overloadedField $ keyField entry) - @@ fieldOfExp (overloadedField $ valueField entry) - RepeatedField packed -> - "Data.ProtoLens.RepeatedField" - @@ if packed == Packed - then "Data.ProtoLens.Packed" - else "Data.ProtoLens.Unpacked" - hsFieldName - = case kind of - OptionalMaybeField -> "maybe'" <> overloadedField f - _ -> overloadedField f - -fieldOfExp :: Symbol -> Exp -fieldOfExp sym = "Data.ProtoLens.Field.field" @@ typeApp (promoteSymbol sym) - -overloadedField :: FieldInfo -> Symbol -overloadedField = overloadedName . fieldName - -fieldTypeDescriptorExpr :: FieldDescriptorProto'Type -> Exp -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 = fromString ("Data.ProtoLens." ++ x) - @@ 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 Name -> Exp -messageRnfExpr msg = lambda ["x__"] $ foldr (@@) "()" (map seqField fieldNames) - where - fieldNames = messageUnknownFields msg - : map (haskellRecordFieldName . fieldName . plainFieldInfo) - (messageFields msg) - ++ map (haskellRecordFieldName . oneofFieldName) - (messageOneofFields msg) - seqField :: Name -> Exp - seqField f = "Control.DeepSeq.deepseq" @@ (var (unQual f) @@ "x__") - --- instance NFData Bar where --- rnf (Foo'a x__) = rnf x__ --- rnf (Bar'b x__) = rnf x__ -oneofRnfMatch :: OneofCase -> Match -oneofRnfMatch c = match "rnf" [unQual (caseConstructorName c) `pApp` ["x__"]] - $ "Control.DeepSeq.rnf" @@ "x__" diff --git a/src/Data/ProtoLens/Compiler/Generate/Encoding.hs b/src/Data/ProtoLens/Compiler/Generate/Encoding.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Generate/Encoding.hs +++ /dev/null @@ -1,638 +0,0 @@ --- | This module generates code for decoding and encoding protocol buffer messages. --- --- Upstream docs: -{-# LANGUAGE DeriveFunctor #-} -{-# LANGUAGE LambdaCase #-} -{-# LANGUAGE NoMonomorphismRestriction #-} -{-# LANGUAGE OverloadedStrings #-} -module Data.ProtoLens.Compiler.Generate.Encoding - ( generatedParser - , generatedBuilder - ) where - -import Data.Int (Int32) -import qualified Data.Map as Map -import Data.Semigroup ((<>)) -import qualified Data.Text as Text -import Lens.Family2 (view, (^.)) - -import Data.ProtoLens.Compiler.Combinators -import Data.ProtoLens.Compiler.Definitions -import Data.ProtoLens.Compiler.Generate.Field -import Data.ProtoLens.Encoding.Wire (joinTypeAndTag) - -import Proto.Google.Protobuf.Descriptor_Fields - ( name - , number - , type' - ) - -generatedParser :: Env QName -> MessageInfo Name -> Exp -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 [match loop (fmap pVar $ loopArgs names) loopExpr] - ] - $ "Data.ProtoLens.Encoding.Bytes." - @@ do' (startStmts ++ [stmt $ continue startExp]) - @@ stringExp msgName - where - ty = tyCon (unQual $ messageName m) - msgName = Text.unpack (messageDescriptor m ^. name) - loopSig = foldr tyFun - ("Data.ProtoLens.Encoding.Bytes.Parser" @@ ty) - (loopArgs $ parseStateTypes env m) - - names = parseStateNames m - exprs = fmap (var . unQual) names - tag = "tag" - end = "end" - loop = "loop" - - (startStmts, startExp) = startParse names - - continue :: ParseState Exp -> Exp - continue s = foldl (@@) 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 $ - (pLitInt (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 <-- "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 Name -> ParseState Exp -> Exp -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} - -} - [ pVar frozen <-- unsafeLiftIO' @@ - ("Data.ProtoLens.Encoding.Growing.unsafeFreeze" - @@ mutable) - | (frozen, mutable) <- Map.elems $ Map.intersectionWith (,) - frozenNames (repeatedFieldMVectors s) - ] - ++ - [ stmt $ checkMissingFields s - , stmt $ "Prelude.return" @@ - (over' unknownFields' "Prelude.reverse" - @@(foldr (@@) - (partialMessage s) - (Map.intersectionWith - (\finfo frozen -> - "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 Name -> ParseState Name -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 Name -> 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 Name -> ([Stmt], ParseState Exp) -startParse names = - ([ pVar n <-- unsafeLiftIO' @@ "Data.ProtoLens.Encoding.Growing.new" - | n <- Map.elems mvectorNames - ] - , ParseState - { partialMessage = "Data.ProtoLens.defMessage" - , requiredFieldsUnset = const "Prelude.True" - <$> requiredFieldsUnset names - , repeatedFieldMVectors = var . unQual <$> mvectorNames - } - ) - where - mvectorNames = repeatedFieldMVectors names - --- | The types of the loop arguments. -parseStateTypes :: Env QName -> MessageInfo Name -> ParseState Type -parseStateTypes env m = ParseState - { partialMessage = tyCon (unQual $ messageName m) - , requiredFieldsUnset = fmap (const "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 :: - Exp -- ^ An expression of type @msg -> msg@ - -> ParseState Exp - -> ParseState Exp -updateParseState f s = s { partialMessage = f @@ (partialMessage s) } - --- | Transform the loop arguments by marking a required field --- as having been set. -markRequiredField :: FieldId -> ParseState Exp -> ParseState Exp -markRequiredField f s = - s { requiredFieldsUnset = Map.insert f "Prelude.False" - $ requiredFieldsUnset s } - --- | Append to the given repeated field. -appendToRepeated :: FieldId -> Exp -> ParseState Exp -> (Stmt, ParseState Exp) -appendToRepeated f x s = - ( v <-- unsafeLiftIO' - @@ ("Data.ProtoLens.Encoding.Growing.append" - @@ (repeatedFieldMVectors s Map.! f) - @@ x) - , s { repeatedFieldMVectors = - Map.insert f (var $ unQual v) - $ repeatedFieldMVectors s - } - ) - where - v = "v" - --- | Returns an Exp of type @Parser ()@ --- which fails if any of the missing fields aren't set. -checkMissingFields :: ParseState Exp -> Exp -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' [patBind missing allMissingFields] - $ if' ("Prelude.null" @@ missing) ("Prelude.return" @@ unit) - $ "Prelude.fail" - @@ ("Prelude.++" - @@ stringExp "Missing required fields: " - @@ ("Prelude.show" @@ (missing @::@ "[Prelude.String]"))) - where - missing = "missing" - allMissingFields = Map.foldrWithKey consIfMissing emptyList (requiredFieldsUnset s) - consIfMissing (FieldId f) e rest = - (if' e (cons @@ stringExp (Text.unpack f)) "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 Exp -> Exp) - -- ^ 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 Exp -- ^ Previous value of the message and required field states - -> MessageInfo Name - -> [Alt] -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 Exp -> Exp) -> ParseState Exp -> PlainFieldInfo -> [Alt] -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 = "y" - entry = "entry" - info = plainFieldInfo f - valueCase = pLitInt (fieldTag info) --> do' - [ y <-- parseField info - , stmt . loop . updateParseState (setField info @@ y) - $ x - ] - requiredCase = pLitInt (fieldTag info) --> do' - [ y <-- parseField info - , stmt . loop - . updateParseState (setField info @@ y) - . markRequiredField (fieldId f) - $ x - ] - unpackedCase = pLitInt (fieldTag info) --> - let (appendStmt, x') = appendToRepeated (fieldId f) y x - in do' - [ bangPat y <-- parseField info - , appendStmt - , stmt . loop $ x' - ] - packedCase = pLitInt (packedFieldTag info) --> do' - [ y <-- isolatedLengthy (parsePackedField info - @@ repeatedFieldMVectors x Map.! fieldId f) - , stmt $ loop x { repeatedFieldMVectors = - Map.insert (fieldId f) (var $ unQual y) - $ repeatedFieldMVectors x } - ] - mapCase entryInfo = pLitInt (fieldTag info) --> do' - [ bangPat (entry `patTypeSig` tyCon (unQual $ mapEntryTypeName entryInfo)) - <-- parseField info - , stmt . let' [ patBind "key" - $ view' @@ fieldOf (keyField entryInfo) - @@ entry - , patBind "value" - $ view' @@ fieldOf (valueField entryInfo) - @@ entry - ] - . loop - . updateParseState - (overField info - ("Data.Map.insert" @@ "key" @@ "value")) - $ x - ] - -unknownFieldCase :: - MessageInfo Name -> (ParseState Exp -> Exp) -> ParseState Exp -> Alt -{- - 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 = wire --> (do' $ - [ bangPat y <-- "Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire" @@ wire - ] - ++ - [ stmt $ case' y - [ pApp "Data.ProtoLens.Encoding.Wire.TaggedValue" - [utag, "Data.ProtoLens.Encoding.Wire.EndGroup"] - --> "Prelude.fail" @@ - ("Prelude.++" - @@ stringExp "Mismatched group-end tag number " - @@ ("Prelude.show" @@ utag)) - , pWildCard --> "Prelude.return" @@ unit - ] - | Just _ <- [groupFieldNumber info] - ] - ++ - [ stmt . loop . updateParseState (over' unknownFields' (cons @@ y)) - $ x - ]) - where - wire = "wire" - y = "y" - utag = "utag" - --- | An expression of type "b -> a -> a", corresponding to a Lens a b --- for this field. -setField :: FieldInfo -> Exp -setField f = "Lens.Family2.set" @@ fieldOf f - --- | An expression of type "(b -> b) -> a -> a", corresponding to a --- Lens a b for this field. -overField :: FieldInfo -> Exp -> Exp -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' :: Exp -> Exp -> Exp -over' f g = "Lens.Family2.over" - @@ f - @@ lambda [bangPat t] (g @@ t) - where - t = "t" - --- | A "Growing v RealWorld a -> Parser (Growing v RealWorld a)" --- for a field that can be packed. -parsePackedField :: FieldInfo -> Exp -{- 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 [match ploop [qs] ploopExp]] - ploop - where - ploop = "ploop" - q = "q" - qs = "qs" - qs' = "qs'" - packedEnd = "packedEnd" - ploopExp = do' - [ packedEnd <-- "Data.ProtoLens.Encoding.Bytes.atEnd" - , stmt $ - if' packedEnd - ("Prelude.return" @@ qs) - $ do' - [ bangPat q <-- parseField info - , qs' <-- unsafeLiftIO' @@ - ("Data.ProtoLens.Encoding.Growing.append" - @@ qs @@ q) - , stmt $ ploop @@ qs' - ] - ] - -generatedBuilder :: MessageInfo Name -> Exp -generatedBuilder m = - lambda [x] $ foldMapExp $ map (buildPlainField x) (messageFields m) - ++ map (buildOneofField x) (messageOneofFields m) - ++ [buildUnknown x] - ++ buildGroupEnd - where - x = "_x" -- TODO: rename to "x" once it's always used - -- If this is a group, finish by emitting the end-group tag. - buildGroupEnd = [ putVarInt' @@ litInt (groupEndTag g) - | Just g <- [groupFieldNumber m] - ] - -buildUnknown :: Exp -> Exp -buildUnknown x - = "Data.ProtoLens.Encoding.Wire.buildFieldSet" - @@ (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 :: [Exp] -> Exp -foldMapExp [] = mempty' -foldMapExp [x] = x -foldMapExp (x:xs) = "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 :: Exp -> PlainFieldInfo -> Exp -buildPlainField x f = case plainFieldKind f of - RequiredField -> buildTaggedField info fieldValue - OptionalMaybeField -> case' maybeFieldValue - ["Prelude.Nothing" --> mempty' - , "Prelude.Just" `pApp` [v] - --> buildTaggedField info v - ] - OptionalValueField -> let' [patBind v fieldValue] - $ if' ("Prelude.==" @@ v @@ "Data.ProtoLens.fieldDefault") - mempty' - (buildTaggedField info v) - MapField entryInfo - -> "Data.Monoid.mconcat" - @@ ("Prelude.map" - @@ lambda [v] (buildEntry entryInfo v) - @@ ("Data.Map.toList" @@ fieldValue)) - RepeatedField Packed -> buildPackedField info vectorFieldValue - RepeatedField _ -> "Data.ProtoLens.Encoding.Bytes.foldMapBuilder" - @@ lambda [v] - (buildTaggedField info v) - @@ vectorFieldValue - where - info = plainFieldInfo f - v = "_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) - @@ ("Prelude.fst" @@ kv) - @@ (set' @@ fieldOf (valueField entry) - @@ ("Prelude.snd" @@ kv) - @@ ("Data.ProtoLens.defMessage" - @::@ tyCon (unQual $ mapEntryTypeName entry))) - -fieldOf :: FieldInfo -> Exp -fieldOf = fieldOfExp . overloadedFieldName - -fieldOfMaybe :: FieldInfo -> Exp -fieldOfMaybe = fieldOfExp . ("maybe'" <>) . overloadedFieldName - -fieldOfOneof :: OneofInfo -> Exp -fieldOfOneof = - fieldOfExp . ("maybe'" <>) . overloadedName . oneofFieldName - -fieldOfVector :: FieldInfo -> Exp -fieldOfVector = fieldOfExp . ("vec'" <>) . overloadedFieldName - --- | Build a field along with its tag. -buildTaggedField :: FieldInfo -> Exp -> Exp -buildTaggedField f x = foldMapExp - [ putVarInt' @@ litInt (fieldTag f) - , buildField f @@ x - ] - --- | Encodes a packed field as a byte string, along with --- its wire type+number. -buildPackedField :: FieldInfo -> Exp -> Exp -{- - 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' [patBind p x] - $ if' ("Data.Vector.Generic.null" @@ p) mempty' - $ "Data.Monoid.<>" - @@ (putVarInt' @@ litInt (packedFieldTag f)) - @@ (buildFieldType lengthy - @@ ("Data.ProtoLens.Encoding.Bytes.runBuilder" - @@ ("Data.ProtoLens.Encoding.Bytes.foldMapBuilder" - @@ buildField f - @@ p))) - where - p = "p" - -buildOneofField :: Exp -> OneofInfo -> Exp -buildOneofField x info = case' (view' @@ fieldOfOneof info @@ x) $ - ("Prelude.Nothing" --> mempty') - : [ pApp "Prelude.Just" [pApp (unQual $ caseConstructorName c) - [v]] - --> buildTaggedField (caseField c) v - | c <- oneofCases info - ] - where - v = "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 -> Exp -fieldOfExp sym = "Data.ProtoLens.Field.field" @@ typeApp (promoteSymbol sym) - --- | Some functions that are used in multiple places in the generated code. -getVarInt', putVarInt', mempty', view', set', unknownFields', unsafeLiftIO' - :: Exp -getVarInt' = "Data.ProtoLens.Encoding.Bytes.getVarInt" -putVarInt' = "Data.ProtoLens.Encoding.Bytes.putVarInt" -mempty' = "Data.Monoid.mempty" -view' = "Lens.Family2.view" -set' = "Lens.Family2.set" -unknownFields' = "Data.ProtoLens.unknownFields" -unsafeLiftIO' = "Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO" - --- | Returns an expression of type @Parser a@ for the given field. -parseField :: FieldInfo -> Exp -parseField f = "Data.ProtoLens.Encoding.Bytes." - @@ (parseFieldType $ fieldInfoEncoding f) - @@ stringExp n - where - n = Text.unpack (fieldDescriptor f ^. name) - --- | Returns a function corresponding to `a -> Builder`: -buildField :: FieldInfo -> Exp -buildField = buildFieldType . fieldInfoEncoding - -fieldInfoEncoding :: FieldInfo -> FieldEncoding -fieldInfoEncoding = fieldEncoding . view type' . fieldDescriptor - -growingType :: Env QName -> FieldInfo -> Type -growingType env f - = "Data.ProtoLens.Encoding.Growing.Growing" - @@ hsFieldVectorType f - @@ "Data.ProtoLens.Encoding.Growing.RealWorld" - @@ hsFieldType env f diff --git a/src/Data/ProtoLens/Compiler/Generate/Field.hs b/src/Data/ProtoLens/Compiler/Generate/Field.hs deleted file mode 100644 --- a/src/Data/ProtoLens/Compiler/Generate/Field.hs +++ /dev/null @@ -1,260 +0,0 @@ -{-# LANGUAGE LambdaCase #-} -{-# LANGUAGE NoMonomorphismRestriction #-} -{-# 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 Proto.Google.Protobuf.Descriptor_Fields (type', typeName) - -import Data.ProtoLens.Compiler.Combinators -import Data.ProtoLens.Compiler.Definitions - -hsFieldType :: Env QName -> FieldInfo -> Type -hsFieldType env f = let - fd = fieldDescriptor f - in 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" - -hsFieldVectorType :: FieldInfo -> Type -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 = "Data.Vector.Vector" - unboxed = "Data.Vector.Unboxed.Vector" - --- | A representation for how to encode and decode a particular field type. -data FieldEncoding = FieldEncoding - { buildFieldType :: Exp -- ^ :: a -> Builder - , parseFieldType :: Exp -- ^ :: 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 = "Data.ProtoLens.Encoding.Bytes.putFixed64" - , parseFieldType = "Data.ProtoLens.Encoding.Bytes.getFixed64" - } - --- | A fixed-length integer (Word32). -fixed32 :: FieldEncoding -fixed32 = FieldEncoding - { wireType = 5 - , buildFieldType = "Data.ProtoLens.Encoding.Bytes.putFixed32" - , parseFieldType = "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 = "bs" - len = "len" - buildLengthy = - -- Bind x since it may be a nontrivial expression: - lambda [bs] - $ "Data.Monoid.<>" - @@ (putVarInt' - @@ (fromIntegral' - @@ ("Data.ByteString.length" @@ bs))) - @@ ("Data.ProtoLens.Encoding.Bytes.putBytes" @@ bs) - parseLengthy = do' - [ len <-- getVarInt' - , stmt $ "Data.ProtoLens.Encoding.Bytes.getBytes" - @@ (fromIntegral' @@ len) - ] - -group :: FieldEncoding -group = FieldEncoding - { wireType = 3 - , buildFieldType = "Data.ProtoLens.buildMessage" - , parseFieldType = "Data.ProtoLens.parseMessage" - } - -groupEnd :: FieldEncoding -groupEnd = FieldEncoding - { wireType = 4 - , buildFieldType = "Prelude.const" @@ "Data.Monoid.mempty" - , parseFieldType = "Prelude.return" @@ unit - } - --- Wrap a field encoding with Haskell functions that should always succeed. -bijectField :: Exp -> Exp -> FieldEncoding -> FieldEncoding -bijectField buildF parseF f = FieldEncoding - { buildFieldType = "Prelude.." @@ buildFieldType f @@ buildF - , parseFieldType = "Prelude.fmap" @@ parseF @@ parseFieldType f - , wireType = wireType f - } - --- | Wrap a field encoding with Haskell functions that may fail during parsing. -partialField :: Exp -> (Exp -> Exp) -> FieldEncoding -> FieldEncoding -partialField buildF parseF f = FieldEncoding - { buildFieldType = "Prelude.." @@ buildFieldType f @@ buildF - -- do - -- value <- ... - -- runEither $ {parseF} value - , parseFieldType = do' - [ value <-- parseFieldType f - , stmt $ runEither @@ parseF value - ] - , wireType = wireType f - } - where - value = "value" - runEither = "Data.ProtoLens.Encoding.Bytes.runEither" - --- | 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 - "Data.ProtoLens.Encoding.Bytes.doubleToWord" - "Data.ProtoLens.Encoding.Bytes.wordToDouble" - fixed64 - FieldDescriptorProto'TYPE_FLOAT -> - bijectField - "Data.ProtoLens.Encoding.Bytes.floatToWord" - "Data.ProtoLens.Encoding.Bytes.wordToFloat" - fixed32 - FieldDescriptorProto'TYPE_BOOL -> - bijectField - (lambda ["b"] $ if' "b" (litInt 1) (litInt 0)) - ("Prelude./=" @@ litInt 0) - varint - FieldDescriptorProto'TYPE_ENUM -> - -- TODO: don't throw an exception on unknown proto2 enums. - bijectField "Prelude.fromEnum" "Prelude.toEnum" - $ integralField varint - FieldDescriptorProto'TYPE_SINT64 -> - bijectField - "Data.ProtoLens.Encoding.Bytes.signedInt64ToWord" - "Data.ProtoLens.Encoding.Bytes.wordToSignedInt64" - $ integralField varint - FieldDescriptorProto'TYPE_SINT32 -> - bijectField - "Data.ProtoLens.Encoding.Bytes.signedInt32ToWord" - "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 = partialField "Data.Text.Encoding.encodeUtf8" decodeUtf8P lengthy - where - {- Translates to: - case decodeUtf8' bytes of - Left err -> Left (show err) - Right r -> r - Equivalently: - first show $ decodeUtf8' bytes - but avoids dragging in Data.Bifunctors. - -} - decodeUtf8P bytes = - case' ("Data.Text.Encoding.decodeUtf8'" @@ bytes ) - [ "Prelude.Left" `pApp` ["err"] - --> "Prelude.Left" @@ ("Prelude.show" @@ "err") - , "Prelude.Right" `pApp` ["r"] - --> "Prelude.Right" @@ "r" - ] - --- | A protobuf message type. -message :: FieldEncoding -message = lengthy - { buildFieldType = "Prelude.." @@ - buildFieldType lengthy @@ - "Data.ProtoLens.encodeMessage" - , parseFieldType = isolatedLengthy "Data.ProtoLens.parseMessage" - } - --- | Takes a @Parser a@, reads a varint and then runs the parser --- isolated to the given length. -isolatedLengthy :: Exp -> Exp -isolatedLengthy parser = do' - [ len <-- getVarInt' - , stmt $ "Data.ProtoLens.Encoding.Bytes.isolate" - @@ (fromIntegral' @@ len) - @@ parser - ] - where - len = "len" - --- | Some functions that are used in multiple places in the generated code. -getVarInt', putVarInt', fromIntegral' :: Exp -getVarInt' = "Data.ProtoLens.Encoding.Bytes.getVarInt" -putVarInt' = "Data.ProtoLens.Encoding.Bytes.putVarInt" -fromIntegral' = "Prelude.fromIntegral" 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,24 @@ +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,130 +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 Data.String (fromString) -import qualified Data.Text as T -import Data.Text (Text) -import Lens.Family2 -import Proto.Google.Protobuf.Descriptor (FileDescriptorProto) -import Proto.Google.Protobuf.Descriptor_Fields (name, dependency, publicDependency) -import System.FilePath (dropExtension, splitDirectories) - - -import Data.ProtoLens.Compiler.Definitions -import Data.ProtoLens.Compiler.Combinators (ModuleName, Name, QName) - --- | The filename of an input .proto file. -type ProtoFileName = Text - -data ProtoFile = ProtoFile - { descriptor :: FileDescriptorProto - , haskellModule :: ModuleName - , definitions :: Env Name - , services :: [ServiceInfo] - -- | 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 - servicesByName = fmap collectServices 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 - , services = servicesByName ! 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 - = fromString $ moduleNameStr (T.unpack modulePrefix) (T.unpack $ fd ^. name) - --- | Get the Haskell module name corresponding to a given .proto file. -moduleNameStr :: String -> FilePath -> String -moduleNameStr prefix 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 - --- | 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 -