{-# LANGUAGE DeriveDataTypeable #-}
-- | A strong feature of the protocol-buffers package is that it does
-- not contain any structures defined by descriptor.proto!  This
-- prevents me hitting any annoying circular dependencies.  The
-- structures defined here are included in each module created by
-- 'hprotoc'.  They are optimized for use in code generation.
--
-- These values can be inspected at runtime by the user's code, but I
-- have yet to write much documentation.  Luckily the record field
-- names are somewhat descriptive.
--
-- The other reflection is using the 'fileDescriptorProto' which
-- is put into the top level module created by hprotoc.
module Text.ProtocolBuffers.Reflections
  ( ProtoName(..),ProtoFName(..),ProtoInfo(..),DescriptorInfo(..),FieldInfo(..),KeyInfo
  , HsDefault(..),SomeRealFloat(..),EnumInfo(..),EnumInfoApp
  , ReflectDescriptor(..),ReflectEnum(..),GetMessageInfo(..)
  , OneofInfo(..)
  , makePNF, toRF, fromRF
  ) where

import Text.ProtocolBuffers.Basic
import Text.ProtocolBuffers.Identifiers

import Data.List(sort)
import qualified Data.Foldable as F(toList)
import Data.Set(Set)
import qualified Data.Set as Set(fromDistinctAscList)
import Data.Generics(Data)
import Data.Typeable(Typeable)
import Data.Map(Map)

-- | 'makePNF' is used by the generated code to create a ProtoName with less newtype noise.
makePNF :: ByteString -> [String] -> [String] -> String -> ProtoName
makePNF :: ByteString -> [String] -> [String] -> String -> ProtoName
makePNF ByteString
a [String]
bs [String]
cs String
d =
  FIName Utf8
-> [MName String] -> [MName String] -> MName String -> ProtoName
ProtoName (Utf8 -> FIName Utf8
forall a. a -> FIName a
FIName (ByteString -> Utf8
Utf8 ByteString
a))
            ((String -> MName String) -> [String] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map String -> MName String
forall a. a -> MName a
MName [String]
bs)
            ((String -> MName String) -> [String] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map String -> MName String
forall a. a -> MName a
MName [String]
cs)
            (String -> MName String
forall a. a -> MName a
MName String
d)

-- | This is fully qualified name data type for code generation.  The
-- 'haskellPrefix' was possibly specified on the 'hprotoc' command
-- line.  The 'parentModule' is a combination of the module prefix
-- from the '.proto' file and any nested levels of definition.
--
-- The name components are likely to have been mangled to ensure the
-- 'baseName' started with an uppercase letter, in @ ['A'..'Z'] @.
data ProtoName = ProtoName { ProtoName -> FIName Utf8
protobufName :: FIName Utf8     -- ^ fully qualified name using "package" prefix (no mangling)
                           , ProtoName -> [MName String]
haskellPrefix :: [MName String] -- ^ Haskell specific prefix to module hierarchy (e.g. Text.Foo)
                           , ProtoName -> [MName String]
parentModule :: [MName String]  -- ^ .proto specified namespace (like Com.Google.Bar)
                           , ProtoName -> MName String
baseName :: MName String
                           }
  deriving (Int -> ProtoName -> ShowS
[ProtoName] -> ShowS
ProtoName -> String
(Int -> ProtoName -> ShowS)
-> (ProtoName -> String)
-> ([ProtoName] -> ShowS)
-> Show ProtoName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtoName] -> ShowS
$cshowList :: [ProtoName] -> ShowS
show :: ProtoName -> String
$cshow :: ProtoName -> String
showsPrec :: Int -> ProtoName -> ShowS
$cshowsPrec :: Int -> ProtoName -> ShowS
Show,ReadPrec [ProtoName]
ReadPrec ProtoName
Int -> ReadS ProtoName
ReadS [ProtoName]
(Int -> ReadS ProtoName)
-> ReadS [ProtoName]
-> ReadPrec ProtoName
-> ReadPrec [ProtoName]
-> Read ProtoName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProtoName]
$creadListPrec :: ReadPrec [ProtoName]
readPrec :: ReadPrec ProtoName
$creadPrec :: ReadPrec ProtoName
readList :: ReadS [ProtoName]
$creadList :: ReadS [ProtoName]
readsPrec :: Int -> ReadS ProtoName
$creadsPrec :: Int -> ReadS ProtoName
Read,ProtoName -> ProtoName -> Bool
(ProtoName -> ProtoName -> Bool)
-> (ProtoName -> ProtoName -> Bool) -> Eq ProtoName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProtoName -> ProtoName -> Bool
$c/= :: ProtoName -> ProtoName -> Bool
== :: ProtoName -> ProtoName -> Bool
$c== :: ProtoName -> ProtoName -> Bool
Eq,Eq ProtoName
Eq ProtoName
-> (ProtoName -> ProtoName -> Ordering)
-> (ProtoName -> ProtoName -> Bool)
-> (ProtoName -> ProtoName -> Bool)
-> (ProtoName -> ProtoName -> Bool)
-> (ProtoName -> ProtoName -> Bool)
-> (ProtoName -> ProtoName -> ProtoName)
-> (ProtoName -> ProtoName -> ProtoName)
-> Ord ProtoName
ProtoName -> ProtoName -> Bool
ProtoName -> ProtoName -> Ordering
ProtoName -> ProtoName -> ProtoName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProtoName -> ProtoName -> ProtoName
$cmin :: ProtoName -> ProtoName -> ProtoName
max :: ProtoName -> ProtoName -> ProtoName
$cmax :: ProtoName -> ProtoName -> ProtoName
>= :: ProtoName -> ProtoName -> Bool
$c>= :: ProtoName -> ProtoName -> Bool
> :: ProtoName -> ProtoName -> Bool
$c> :: ProtoName -> ProtoName -> Bool
<= :: ProtoName -> ProtoName -> Bool
$c<= :: ProtoName -> ProtoName -> Bool
< :: ProtoName -> ProtoName -> Bool
$c< :: ProtoName -> ProtoName -> Bool
compare :: ProtoName -> ProtoName -> Ordering
$ccompare :: ProtoName -> ProtoName -> Ordering
$cp1Ord :: Eq ProtoName
Ord,Typeable ProtoName
DataType
Constr
Typeable ProtoName
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProtoName -> c ProtoName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProtoName)
-> (ProtoName -> Constr)
-> (ProtoName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProtoName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoName))
-> ((forall b. Data b => b -> b) -> ProtoName -> ProtoName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProtoName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProtoName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName)
-> Data ProtoName
ProtoName -> DataType
ProtoName -> Constr
(forall b. Data b => b -> b) -> ProtoName -> ProtoName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoName -> c ProtoName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoName
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProtoName -> u
forall u. (forall d. Data d => d -> u) -> ProtoName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoName -> c ProtoName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoName)
$cProtoName :: Constr
$tProtoName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
gmapMp :: (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
gmapM :: (forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoName -> m ProtoName
gmapQi :: Int -> (forall d. Data d => d -> u) -> ProtoName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProtoName -> u
gmapQ :: (forall d. Data d => d -> u) -> ProtoName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProtoName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoName -> r
gmapT :: (forall b. Data b => b -> b) -> ProtoName -> ProtoName
$cgmapT :: (forall b. Data b => b -> b) -> ProtoName -> ProtoName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ProtoName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoName)
dataTypeOf :: ProtoName -> DataType
$cdataTypeOf :: ProtoName -> DataType
toConstr :: ProtoName -> Constr
$ctoConstr :: ProtoName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoName -> c ProtoName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoName -> c ProtoName
$cp1Data :: Typeable ProtoName
Data,Typeable)

data ProtoFName = ProtoFName { ProtoFName -> FIName Utf8
protobufName' :: FIName Utf8     -- ^ fully qualified name using "package" prefix (no mangling)
                             , ProtoFName -> [MName String]
haskellPrefix' :: [MName String] -- ^ Haskell specific prefix to module hierarchy (e.g. Text.Foo)
                             , ProtoFName -> [MName String]
parentModule' :: [MName String]  -- ^ .proto specified namespace (like Com.Google.Bar)
                             , ProtoFName -> FName String
baseName' :: FName String
                             , ProtoFName -> String
baseNamePrefix' :: String -- "_" if lenses are generated
                             }
  deriving (Int -> ProtoFName -> ShowS
[ProtoFName] -> ShowS
ProtoFName -> String
(Int -> ProtoFName -> ShowS)
-> (ProtoFName -> String)
-> ([ProtoFName] -> ShowS)
-> Show ProtoFName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtoFName] -> ShowS
$cshowList :: [ProtoFName] -> ShowS
show :: ProtoFName -> String
$cshow :: ProtoFName -> String
showsPrec :: Int -> ProtoFName -> ShowS
$cshowsPrec :: Int -> ProtoFName -> ShowS
Show,ReadPrec [ProtoFName]
ReadPrec ProtoFName
Int -> ReadS ProtoFName
ReadS [ProtoFName]
(Int -> ReadS ProtoFName)
-> ReadS [ProtoFName]
-> ReadPrec ProtoFName
-> ReadPrec [ProtoFName]
-> Read ProtoFName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProtoFName]
$creadListPrec :: ReadPrec [ProtoFName]
readPrec :: ReadPrec ProtoFName
$creadPrec :: ReadPrec ProtoFName
readList :: ReadS [ProtoFName]
$creadList :: ReadS [ProtoFName]
readsPrec :: Int -> ReadS ProtoFName
$creadsPrec :: Int -> ReadS ProtoFName
Read,ProtoFName -> ProtoFName -> Bool
(ProtoFName -> ProtoFName -> Bool)
-> (ProtoFName -> ProtoFName -> Bool) -> Eq ProtoFName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProtoFName -> ProtoFName -> Bool
$c/= :: ProtoFName -> ProtoFName -> Bool
== :: ProtoFName -> ProtoFName -> Bool
$c== :: ProtoFName -> ProtoFName -> Bool
Eq,Eq ProtoFName
Eq ProtoFName
-> (ProtoFName -> ProtoFName -> Ordering)
-> (ProtoFName -> ProtoFName -> Bool)
-> (ProtoFName -> ProtoFName -> Bool)
-> (ProtoFName -> ProtoFName -> Bool)
-> (ProtoFName -> ProtoFName -> Bool)
-> (ProtoFName -> ProtoFName -> ProtoFName)
-> (ProtoFName -> ProtoFName -> ProtoFName)
-> Ord ProtoFName
ProtoFName -> ProtoFName -> Bool
ProtoFName -> ProtoFName -> Ordering
ProtoFName -> ProtoFName -> ProtoFName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProtoFName -> ProtoFName -> ProtoFName
$cmin :: ProtoFName -> ProtoFName -> ProtoFName
max :: ProtoFName -> ProtoFName -> ProtoFName
$cmax :: ProtoFName -> ProtoFName -> ProtoFName
>= :: ProtoFName -> ProtoFName -> Bool
$c>= :: ProtoFName -> ProtoFName -> Bool
> :: ProtoFName -> ProtoFName -> Bool
$c> :: ProtoFName -> ProtoFName -> Bool
<= :: ProtoFName -> ProtoFName -> Bool
$c<= :: ProtoFName -> ProtoFName -> Bool
< :: ProtoFName -> ProtoFName -> Bool
$c< :: ProtoFName -> ProtoFName -> Bool
compare :: ProtoFName -> ProtoFName -> Ordering
$ccompare :: ProtoFName -> ProtoFName -> Ordering
$cp1Ord :: Eq ProtoFName
Ord,Typeable ProtoFName
DataType
Constr
Typeable ProtoFName
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProtoFName -> c ProtoFName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProtoFName)
-> (ProtoFName -> Constr)
-> (ProtoFName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProtoFName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ProtoFName))
-> ((forall b. Data b => b -> b) -> ProtoFName -> ProtoFName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoFName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoFName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProtoFName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProtoFName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName)
-> Data ProtoFName
ProtoFName -> DataType
ProtoFName -> Constr
(forall b. Data b => b -> b) -> ProtoFName -> ProtoFName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoFName -> c ProtoFName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoFName
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProtoFName -> u
forall u. (forall d. Data d => d -> u) -> ProtoFName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoFName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoFName -> c ProtoFName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoFName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoFName)
$cProtoFName :: Constr
$tProtoFName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
gmapMp :: (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
gmapM :: (forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoFName -> m ProtoFName
gmapQi :: Int -> (forall d. Data d => d -> u) -> ProtoFName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProtoFName -> u
gmapQ :: (forall d. Data d => d -> u) -> ProtoFName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProtoFName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoFName -> r
gmapT :: (forall b. Data b => b -> b) -> ProtoFName -> ProtoFName
$cgmapT :: (forall b. Data b => b -> b) -> ProtoFName -> ProtoFName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoFName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoFName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ProtoFName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoFName)
dataTypeOf :: ProtoFName -> DataType
$cdataTypeOf :: ProtoFName -> DataType
toConstr :: ProtoFName -> Constr
$ctoConstr :: ProtoFName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoFName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoFName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoFName -> c ProtoFName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoFName -> c ProtoFName
$cp1Data :: Typeable ProtoFName
Data,Typeable)

data ProtoInfo = ProtoInfo { ProtoInfo -> ProtoName
protoMod :: ProtoName        -- ^ blank protobufName, maybe blank haskellPrefix and/or parentModule
                           , ProtoInfo -> [String]
protoFilePath :: [FilePath]  -- ^ path to haskell module
                           , ProtoInfo -> String
protoSource :: FilePath      -- ^ filename without path of .proto file
                           , ProtoInfo -> Seq KeyInfo
extensionKeys :: Seq KeyInfo -- ^ top level keys
                           , ProtoInfo -> [DescriptorInfo]
messages :: [DescriptorInfo] -- ^ all messages and groups
                           , ProtoInfo -> [EnumInfo]
enums :: [EnumInfo]          -- ^ all enums
                           , ProtoInfo -> [OneofInfo]
oneofs :: [OneofInfo]
                           , ProtoInfo -> Map ProtoName (Seq FieldInfo)
knownKeyMap :: Map ProtoName (Seq FieldInfo) -- all keys in namespace
                           }
  deriving (Int -> ProtoInfo -> ShowS
[ProtoInfo] -> ShowS
ProtoInfo -> String
(Int -> ProtoInfo -> ShowS)
-> (ProtoInfo -> String)
-> ([ProtoInfo] -> ShowS)
-> Show ProtoInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtoInfo] -> ShowS
$cshowList :: [ProtoInfo] -> ShowS
show :: ProtoInfo -> String
$cshow :: ProtoInfo -> String
showsPrec :: Int -> ProtoInfo -> ShowS
$cshowsPrec :: Int -> ProtoInfo -> ShowS
Show,ReadPrec [ProtoInfo]
ReadPrec ProtoInfo
Int -> ReadS ProtoInfo
ReadS [ProtoInfo]
(Int -> ReadS ProtoInfo)
-> ReadS [ProtoInfo]
-> ReadPrec ProtoInfo
-> ReadPrec [ProtoInfo]
-> Read ProtoInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProtoInfo]
$creadListPrec :: ReadPrec [ProtoInfo]
readPrec :: ReadPrec ProtoInfo
$creadPrec :: ReadPrec ProtoInfo
readList :: ReadS [ProtoInfo]
$creadList :: ReadS [ProtoInfo]
readsPrec :: Int -> ReadS ProtoInfo
$creadsPrec :: Int -> ReadS ProtoInfo
Read,ProtoInfo -> ProtoInfo -> Bool
(ProtoInfo -> ProtoInfo -> Bool)
-> (ProtoInfo -> ProtoInfo -> Bool) -> Eq ProtoInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProtoInfo -> ProtoInfo -> Bool
$c/= :: ProtoInfo -> ProtoInfo -> Bool
== :: ProtoInfo -> ProtoInfo -> Bool
$c== :: ProtoInfo -> ProtoInfo -> Bool
Eq,Eq ProtoInfo
Eq ProtoInfo
-> (ProtoInfo -> ProtoInfo -> Ordering)
-> (ProtoInfo -> ProtoInfo -> Bool)
-> (ProtoInfo -> ProtoInfo -> Bool)
-> (ProtoInfo -> ProtoInfo -> Bool)
-> (ProtoInfo -> ProtoInfo -> Bool)
-> (ProtoInfo -> ProtoInfo -> ProtoInfo)
-> (ProtoInfo -> ProtoInfo -> ProtoInfo)
-> Ord ProtoInfo
ProtoInfo -> ProtoInfo -> Bool
ProtoInfo -> ProtoInfo -> Ordering
ProtoInfo -> ProtoInfo -> ProtoInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProtoInfo -> ProtoInfo -> ProtoInfo
$cmin :: ProtoInfo -> ProtoInfo -> ProtoInfo
max :: ProtoInfo -> ProtoInfo -> ProtoInfo
$cmax :: ProtoInfo -> ProtoInfo -> ProtoInfo
>= :: ProtoInfo -> ProtoInfo -> Bool
$c>= :: ProtoInfo -> ProtoInfo -> Bool
> :: ProtoInfo -> ProtoInfo -> Bool
$c> :: ProtoInfo -> ProtoInfo -> Bool
<= :: ProtoInfo -> ProtoInfo -> Bool
$c<= :: ProtoInfo -> ProtoInfo -> Bool
< :: ProtoInfo -> ProtoInfo -> Bool
$c< :: ProtoInfo -> ProtoInfo -> Bool
compare :: ProtoInfo -> ProtoInfo -> Ordering
$ccompare :: ProtoInfo -> ProtoInfo -> Ordering
$cp1Ord :: Eq ProtoInfo
Ord,Typeable ProtoInfo
DataType
Constr
Typeable ProtoInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProtoInfo -> c ProtoInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProtoInfo)
-> (ProtoInfo -> Constr)
-> (ProtoInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProtoInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoInfo))
-> ((forall b. Data b => b -> b) -> ProtoInfo -> ProtoInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ProtoInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ProtoInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo)
-> Data ProtoInfo
ProtoInfo -> DataType
ProtoInfo -> Constr
(forall b. Data b => b -> b) -> ProtoInfo -> ProtoInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoInfo -> c ProtoInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ProtoInfo -> u
forall u. (forall d. Data d => d -> u) -> ProtoInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoInfo -> c ProtoInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoInfo)
$cProtoInfo :: Constr
$tProtoInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
gmapMp :: (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
gmapM :: (forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ProtoInfo -> m ProtoInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> ProtoInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProtoInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> ProtoInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProtoInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ProtoInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ProtoInfo -> ProtoInfo
$cgmapT :: (forall b. Data b => b -> b) -> ProtoInfo -> ProtoInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProtoInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ProtoInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ProtoInfo)
dataTypeOf :: ProtoInfo -> DataType
$cdataTypeOf :: ProtoInfo -> DataType
toConstr :: ProtoInfo -> Constr
$ctoConstr :: ProtoInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ProtoInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoInfo -> c ProtoInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ProtoInfo -> c ProtoInfo
$cp1Data :: Typeable ProtoInfo
Data,Typeable)

data DescriptorInfo = DescriptorInfo { DescriptorInfo -> ProtoName
descName :: ProtoName
                                     , DescriptorInfo -> [String]
descFilePath :: [FilePath]
                                     , DescriptorInfo -> Bool
isGroup :: Bool
                                     , DescriptorInfo -> Seq FieldInfo
fields :: Seq FieldInfo
                                     , DescriptorInfo -> Seq OneofInfo
descOneofs :: Seq OneofInfo 
                                     , DescriptorInfo -> Seq KeyInfo
keys :: Seq KeyInfo
                                     , DescriptorInfo -> [(FieldId, FieldId)]
extRanges :: [(FieldId,FieldId)]
                                     , DescriptorInfo -> Seq FieldInfo
knownKeys :: Seq FieldInfo
                                     , DescriptorInfo -> Bool
storeUnknown :: Bool
                                     , DescriptorInfo -> Bool
lazyFields :: Bool
                                     , DescriptorInfo -> Bool
makeLenses :: Bool
                                     , DescriptorInfo -> Bool
jsonInstances :: Bool
                                     }
  deriving (Int -> DescriptorInfo -> ShowS
[DescriptorInfo] -> ShowS
DescriptorInfo -> String
(Int -> DescriptorInfo -> ShowS)
-> (DescriptorInfo -> String)
-> ([DescriptorInfo] -> ShowS)
-> Show DescriptorInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescriptorInfo] -> ShowS
$cshowList :: [DescriptorInfo] -> ShowS
show :: DescriptorInfo -> String
$cshow :: DescriptorInfo -> String
showsPrec :: Int -> DescriptorInfo -> ShowS
$cshowsPrec :: Int -> DescriptorInfo -> ShowS
Show,ReadPrec [DescriptorInfo]
ReadPrec DescriptorInfo
Int -> ReadS DescriptorInfo
ReadS [DescriptorInfo]
(Int -> ReadS DescriptorInfo)
-> ReadS [DescriptorInfo]
-> ReadPrec DescriptorInfo
-> ReadPrec [DescriptorInfo]
-> Read DescriptorInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescriptorInfo]
$creadListPrec :: ReadPrec [DescriptorInfo]
readPrec :: ReadPrec DescriptorInfo
$creadPrec :: ReadPrec DescriptorInfo
readList :: ReadS [DescriptorInfo]
$creadList :: ReadS [DescriptorInfo]
readsPrec :: Int -> ReadS DescriptorInfo
$creadsPrec :: Int -> ReadS DescriptorInfo
Read,DescriptorInfo -> DescriptorInfo -> Bool
(DescriptorInfo -> DescriptorInfo -> Bool)
-> (DescriptorInfo -> DescriptorInfo -> Bool) -> Eq DescriptorInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescriptorInfo -> DescriptorInfo -> Bool
$c/= :: DescriptorInfo -> DescriptorInfo -> Bool
== :: DescriptorInfo -> DescriptorInfo -> Bool
$c== :: DescriptorInfo -> DescriptorInfo -> Bool
Eq,Eq DescriptorInfo
Eq DescriptorInfo
-> (DescriptorInfo -> DescriptorInfo -> Ordering)
-> (DescriptorInfo -> DescriptorInfo -> Bool)
-> (DescriptorInfo -> DescriptorInfo -> Bool)
-> (DescriptorInfo -> DescriptorInfo -> Bool)
-> (DescriptorInfo -> DescriptorInfo -> Bool)
-> (DescriptorInfo -> DescriptorInfo -> DescriptorInfo)
-> (DescriptorInfo -> DescriptorInfo -> DescriptorInfo)
-> Ord DescriptorInfo
DescriptorInfo -> DescriptorInfo -> Bool
DescriptorInfo -> DescriptorInfo -> Ordering
DescriptorInfo -> DescriptorInfo -> DescriptorInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DescriptorInfo -> DescriptorInfo -> DescriptorInfo
$cmin :: DescriptorInfo -> DescriptorInfo -> DescriptorInfo
max :: DescriptorInfo -> DescriptorInfo -> DescriptorInfo
$cmax :: DescriptorInfo -> DescriptorInfo -> DescriptorInfo
>= :: DescriptorInfo -> DescriptorInfo -> Bool
$c>= :: DescriptorInfo -> DescriptorInfo -> Bool
> :: DescriptorInfo -> DescriptorInfo -> Bool
$c> :: DescriptorInfo -> DescriptorInfo -> Bool
<= :: DescriptorInfo -> DescriptorInfo -> Bool
$c<= :: DescriptorInfo -> DescriptorInfo -> Bool
< :: DescriptorInfo -> DescriptorInfo -> Bool
$c< :: DescriptorInfo -> DescriptorInfo -> Bool
compare :: DescriptorInfo -> DescriptorInfo -> Ordering
$ccompare :: DescriptorInfo -> DescriptorInfo -> Ordering
$cp1Ord :: Eq DescriptorInfo
Ord,Typeable DescriptorInfo
DataType
Constr
Typeable DescriptorInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DescriptorInfo -> c DescriptorInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DescriptorInfo)
-> (DescriptorInfo -> Constr)
-> (DescriptorInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DescriptorInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DescriptorInfo))
-> ((forall b. Data b => b -> b)
    -> DescriptorInfo -> DescriptorInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DescriptorInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DescriptorInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DescriptorInfo -> m DescriptorInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DescriptorInfo -> m DescriptorInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DescriptorInfo -> m DescriptorInfo)
-> Data DescriptorInfo
DescriptorInfo -> DataType
DescriptorInfo -> Constr
(forall b. Data b => b -> b) -> DescriptorInfo -> DescriptorInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DescriptorInfo -> c DescriptorInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DescriptorInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DescriptorInfo -> u
forall u. (forall d. Data d => d -> u) -> DescriptorInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DescriptorInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DescriptorInfo -> c DescriptorInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DescriptorInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DescriptorInfo)
$cDescriptorInfo :: Constr
$tDescriptorInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
gmapMp :: (forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
gmapM :: (forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DescriptorInfo -> m DescriptorInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> DescriptorInfo -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DescriptorInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> DescriptorInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DescriptorInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DescriptorInfo -> r
gmapT :: (forall b. Data b => b -> b) -> DescriptorInfo -> DescriptorInfo
$cgmapT :: (forall b. Data b => b -> b) -> DescriptorInfo -> DescriptorInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DescriptorInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DescriptorInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DescriptorInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DescriptorInfo)
dataTypeOf :: DescriptorInfo -> DataType
$cdataTypeOf :: DescriptorInfo -> DataType
toConstr :: DescriptorInfo -> Constr
$ctoConstr :: DescriptorInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DescriptorInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DescriptorInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DescriptorInfo -> c DescriptorInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DescriptorInfo -> c DescriptorInfo
$cp1Data :: Typeable DescriptorInfo
Data,Typeable)


-- | 'GetMessageInfo' is used in getting messages from the wire.  It
-- supplies the 'Set' of precomposed wire tags that must be found in
-- the message as well as a 'Set' of all allowed tags (including known
-- extension fields and all required wire tags).
--
-- Extension fields not in the allowedTags set are still loaded, but
-- only as 'ByteString' blobs that will have to interpreted later.
data GetMessageInfo = GetMessageInfo { GetMessageInfo -> Set WireTag
requiredTags :: Set WireTag
                                     , GetMessageInfo -> Set WireTag
allowedTags :: Set WireTag
                                     }
  deriving (Int -> GetMessageInfo -> ShowS
[GetMessageInfo] -> ShowS
GetMessageInfo -> String
(Int -> GetMessageInfo -> ShowS)
-> (GetMessageInfo -> String)
-> ([GetMessageInfo] -> ShowS)
-> Show GetMessageInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetMessageInfo] -> ShowS
$cshowList :: [GetMessageInfo] -> ShowS
show :: GetMessageInfo -> String
$cshow :: GetMessageInfo -> String
showsPrec :: Int -> GetMessageInfo -> ShowS
$cshowsPrec :: Int -> GetMessageInfo -> ShowS
Show,ReadPrec [GetMessageInfo]
ReadPrec GetMessageInfo
Int -> ReadS GetMessageInfo
ReadS [GetMessageInfo]
(Int -> ReadS GetMessageInfo)
-> ReadS [GetMessageInfo]
-> ReadPrec GetMessageInfo
-> ReadPrec [GetMessageInfo]
-> Read GetMessageInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetMessageInfo]
$creadListPrec :: ReadPrec [GetMessageInfo]
readPrec :: ReadPrec GetMessageInfo
$creadPrec :: ReadPrec GetMessageInfo
readList :: ReadS [GetMessageInfo]
$creadList :: ReadS [GetMessageInfo]
readsPrec :: Int -> ReadS GetMessageInfo
$creadsPrec :: Int -> ReadS GetMessageInfo
Read,GetMessageInfo -> GetMessageInfo -> Bool
(GetMessageInfo -> GetMessageInfo -> Bool)
-> (GetMessageInfo -> GetMessageInfo -> Bool) -> Eq GetMessageInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetMessageInfo -> GetMessageInfo -> Bool
$c/= :: GetMessageInfo -> GetMessageInfo -> Bool
== :: GetMessageInfo -> GetMessageInfo -> Bool
$c== :: GetMessageInfo -> GetMessageInfo -> Bool
Eq,Eq GetMessageInfo
Eq GetMessageInfo
-> (GetMessageInfo -> GetMessageInfo -> Ordering)
-> (GetMessageInfo -> GetMessageInfo -> Bool)
-> (GetMessageInfo -> GetMessageInfo -> Bool)
-> (GetMessageInfo -> GetMessageInfo -> Bool)
-> (GetMessageInfo -> GetMessageInfo -> Bool)
-> (GetMessageInfo -> GetMessageInfo -> GetMessageInfo)
-> (GetMessageInfo -> GetMessageInfo -> GetMessageInfo)
-> Ord GetMessageInfo
GetMessageInfo -> GetMessageInfo -> Bool
GetMessageInfo -> GetMessageInfo -> Ordering
GetMessageInfo -> GetMessageInfo -> GetMessageInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GetMessageInfo -> GetMessageInfo -> GetMessageInfo
$cmin :: GetMessageInfo -> GetMessageInfo -> GetMessageInfo
max :: GetMessageInfo -> GetMessageInfo -> GetMessageInfo
$cmax :: GetMessageInfo -> GetMessageInfo -> GetMessageInfo
>= :: GetMessageInfo -> GetMessageInfo -> Bool
$c>= :: GetMessageInfo -> GetMessageInfo -> Bool
> :: GetMessageInfo -> GetMessageInfo -> Bool
$c> :: GetMessageInfo -> GetMessageInfo -> Bool
<= :: GetMessageInfo -> GetMessageInfo -> Bool
$c<= :: GetMessageInfo -> GetMessageInfo -> Bool
< :: GetMessageInfo -> GetMessageInfo -> Bool
$c< :: GetMessageInfo -> GetMessageInfo -> Bool
compare :: GetMessageInfo -> GetMessageInfo -> Ordering
$ccompare :: GetMessageInfo -> GetMessageInfo -> Ordering
$cp1Ord :: Eq GetMessageInfo
Ord,Typeable GetMessageInfo
DataType
Constr
Typeable GetMessageInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GetMessageInfo -> c GetMessageInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GetMessageInfo)
-> (GetMessageInfo -> Constr)
-> (GetMessageInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GetMessageInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GetMessageInfo))
-> ((forall b. Data b => b -> b)
    -> GetMessageInfo -> GetMessageInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> GetMessageInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GetMessageInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GetMessageInfo -> m GetMessageInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GetMessageInfo -> m GetMessageInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GetMessageInfo -> m GetMessageInfo)
-> Data GetMessageInfo
GetMessageInfo -> DataType
GetMessageInfo -> Constr
(forall b. Data b => b -> b) -> GetMessageInfo -> GetMessageInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GetMessageInfo -> c GetMessageInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GetMessageInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> GetMessageInfo -> u
forall u. (forall d. Data d => d -> u) -> GetMessageInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GetMessageInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GetMessageInfo -> c GetMessageInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GetMessageInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GetMessageInfo)
$cGetMessageInfo :: Constr
$tGetMessageInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
gmapMp :: (forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
gmapM :: (forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GetMessageInfo -> m GetMessageInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> GetMessageInfo -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GetMessageInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> GetMessageInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GetMessageInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GetMessageInfo -> r
gmapT :: (forall b. Data b => b -> b) -> GetMessageInfo -> GetMessageInfo
$cgmapT :: (forall b. Data b => b -> b) -> GetMessageInfo -> GetMessageInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GetMessageInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GetMessageInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GetMessageInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GetMessageInfo)
dataTypeOf :: GetMessageInfo -> DataType
$cdataTypeOf :: GetMessageInfo -> DataType
toConstr :: GetMessageInfo -> Constr
$ctoConstr :: GetMessageInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GetMessageInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GetMessageInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GetMessageInfo -> c GetMessageInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GetMessageInfo -> c GetMessageInfo
$cp1Data :: Typeable GetMessageInfo
Data,Typeable)

type KeyInfo = (ProtoName,FieldInfo) -- Extendee and FieldInfo

data FieldInfo = FieldInfo { FieldInfo -> ProtoFName
fieldName     :: ProtoFName
                           , FieldInfo -> FieldId
fieldNumber   :: FieldId
                           , FieldInfo -> WireTag
wireTag       :: WireTag          -- ^ Used for writing and reading if packedTag is Nothing
                           , FieldInfo -> Maybe (WireTag, WireTag)
packedTag     :: Maybe (WireTag,WireTag) -- ^ used for reading when Just {} instead of wireTag
                           , FieldInfo -> WireSize
wireTagLength :: WireSize         -- ^ Bytes required in the Varint formatted wireTag
                           , FieldInfo -> Bool
isPacked      :: Bool
                           , FieldInfo -> Bool
isRequired    :: Bool
                           , FieldInfo -> Bool
canRepeat     :: Bool             -- ^ True if repeated is the field type
                           , FieldInfo -> Bool
mightPack     :: Bool             -- ^ True if packed would be valid for this field type
                           , FieldInfo -> FieldType
typeCode      :: FieldType        -- ^ fromEnum of Text.DescriptorProtos.FieldDescriptorProto.Type
                           , FieldInfo -> Maybe ProtoName
typeName      :: Maybe ProtoName  -- ^ Set for Messages,Groups,and Enums
                           , FieldInfo -> Maybe ByteString
hsRawDefault  :: Maybe ByteString -- ^ crappy, but not escaped, thing
                           , FieldInfo -> Maybe HsDefault
hsDefault     :: Maybe HsDefault  -- ^ nice parsed thing
                           }
  deriving (Int -> FieldInfo -> ShowS
[FieldInfo] -> ShowS
FieldInfo -> String
(Int -> FieldInfo -> ShowS)
-> (FieldInfo -> String)
-> ([FieldInfo] -> ShowS)
-> Show FieldInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldInfo] -> ShowS
$cshowList :: [FieldInfo] -> ShowS
show :: FieldInfo -> String
$cshow :: FieldInfo -> String
showsPrec :: Int -> FieldInfo -> ShowS
$cshowsPrec :: Int -> FieldInfo -> ShowS
Show,ReadPrec [FieldInfo]
ReadPrec FieldInfo
Int -> ReadS FieldInfo
ReadS [FieldInfo]
(Int -> ReadS FieldInfo)
-> ReadS [FieldInfo]
-> ReadPrec FieldInfo
-> ReadPrec [FieldInfo]
-> Read FieldInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldInfo]
$creadListPrec :: ReadPrec [FieldInfo]
readPrec :: ReadPrec FieldInfo
$creadPrec :: ReadPrec FieldInfo
readList :: ReadS [FieldInfo]
$creadList :: ReadS [FieldInfo]
readsPrec :: Int -> ReadS FieldInfo
$creadsPrec :: Int -> ReadS FieldInfo
Read,FieldInfo -> FieldInfo -> Bool
(FieldInfo -> FieldInfo -> Bool)
-> (FieldInfo -> FieldInfo -> Bool) -> Eq FieldInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldInfo -> FieldInfo -> Bool
$c/= :: FieldInfo -> FieldInfo -> Bool
== :: FieldInfo -> FieldInfo -> Bool
$c== :: FieldInfo -> FieldInfo -> Bool
Eq,Eq FieldInfo
Eq FieldInfo
-> (FieldInfo -> FieldInfo -> Ordering)
-> (FieldInfo -> FieldInfo -> Bool)
-> (FieldInfo -> FieldInfo -> Bool)
-> (FieldInfo -> FieldInfo -> Bool)
-> (FieldInfo -> FieldInfo -> Bool)
-> (FieldInfo -> FieldInfo -> FieldInfo)
-> (FieldInfo -> FieldInfo -> FieldInfo)
-> Ord FieldInfo
FieldInfo -> FieldInfo -> Bool
FieldInfo -> FieldInfo -> Ordering
FieldInfo -> FieldInfo -> FieldInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FieldInfo -> FieldInfo -> FieldInfo
$cmin :: FieldInfo -> FieldInfo -> FieldInfo
max :: FieldInfo -> FieldInfo -> FieldInfo
$cmax :: FieldInfo -> FieldInfo -> FieldInfo
>= :: FieldInfo -> FieldInfo -> Bool
$c>= :: FieldInfo -> FieldInfo -> Bool
> :: FieldInfo -> FieldInfo -> Bool
$c> :: FieldInfo -> FieldInfo -> Bool
<= :: FieldInfo -> FieldInfo -> Bool
$c<= :: FieldInfo -> FieldInfo -> Bool
< :: FieldInfo -> FieldInfo -> Bool
$c< :: FieldInfo -> FieldInfo -> Bool
compare :: FieldInfo -> FieldInfo -> Ordering
$ccompare :: FieldInfo -> FieldInfo -> Ordering
$cp1Ord :: Eq FieldInfo
Ord,Typeable FieldInfo
DataType
Constr
Typeable FieldInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldInfo -> c FieldInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldInfo)
-> (FieldInfo -> Constr)
-> (FieldInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldInfo))
-> ((forall b. Data b => b -> b) -> FieldInfo -> FieldInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo)
-> Data FieldInfo
FieldInfo -> DataType
FieldInfo -> Constr
(forall b. Data b => b -> b) -> FieldInfo -> FieldInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldInfo -> c FieldInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FieldInfo -> u
forall u. (forall d. Data d => d -> u) -> FieldInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldInfo -> c FieldInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldInfo)
$cFieldInfo :: Constr
$tFieldInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
gmapMp :: (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
gmapM :: (forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldInfo -> m FieldInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldInfo -> r
gmapT :: (forall b. Data b => b -> b) -> FieldInfo -> FieldInfo
$cgmapT :: (forall b. Data b => b -> b) -> FieldInfo -> FieldInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldInfo)
dataTypeOf :: FieldInfo -> DataType
$cdataTypeOf :: FieldInfo -> DataType
toConstr :: FieldInfo -> Constr
$ctoConstr :: FieldInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldInfo -> c FieldInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldInfo -> c FieldInfo
$cp1Data :: Typeable FieldInfo
Data,Typeable)

-- | 'HsDefault' stores the parsed default from the proto file in a
-- form that will make a nice literal in the
-- "Language.Haskell.Exts.Syntax" code generation by 'hprotoc'.
--
-- Note that Utf8 labeled byte sequences have been stripped to just
-- 'ByteString' here as this is sufficient for code generation.
--
-- On 25 August 2010 20:12, George van den Driessche <georgevdd@google.com> sent Chris Kuklewicz a
-- patch to MakeReflections.parseDefEnum to ensure that HsDef'Enum holds the mangled form of the
-- name.
data HsDefault = HsDef'Bool Bool
               | HsDef'ByteString ByteString
               | HsDef'RealFloat SomeRealFloat
               | HsDef'Integer Integer
               | HsDef'Enum String
  deriving (Int -> HsDefault -> ShowS
[HsDefault] -> ShowS
HsDefault -> String
(Int -> HsDefault -> ShowS)
-> (HsDefault -> String)
-> ([HsDefault] -> ShowS)
-> Show HsDefault
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HsDefault] -> ShowS
$cshowList :: [HsDefault] -> ShowS
show :: HsDefault -> String
$cshow :: HsDefault -> String
showsPrec :: Int -> HsDefault -> ShowS
$cshowsPrec :: Int -> HsDefault -> ShowS
Show,ReadPrec [HsDefault]
ReadPrec HsDefault
Int -> ReadS HsDefault
ReadS [HsDefault]
(Int -> ReadS HsDefault)
-> ReadS [HsDefault]
-> ReadPrec HsDefault
-> ReadPrec [HsDefault]
-> Read HsDefault
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [HsDefault]
$creadListPrec :: ReadPrec [HsDefault]
readPrec :: ReadPrec HsDefault
$creadPrec :: ReadPrec HsDefault
readList :: ReadS [HsDefault]
$creadList :: ReadS [HsDefault]
readsPrec :: Int -> ReadS HsDefault
$creadsPrec :: Int -> ReadS HsDefault
Read,HsDefault -> HsDefault -> Bool
(HsDefault -> HsDefault -> Bool)
-> (HsDefault -> HsDefault -> Bool) -> Eq HsDefault
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HsDefault -> HsDefault -> Bool
$c/= :: HsDefault -> HsDefault -> Bool
== :: HsDefault -> HsDefault -> Bool
$c== :: HsDefault -> HsDefault -> Bool
Eq,Eq HsDefault
Eq HsDefault
-> (HsDefault -> HsDefault -> Ordering)
-> (HsDefault -> HsDefault -> Bool)
-> (HsDefault -> HsDefault -> Bool)
-> (HsDefault -> HsDefault -> Bool)
-> (HsDefault -> HsDefault -> Bool)
-> (HsDefault -> HsDefault -> HsDefault)
-> (HsDefault -> HsDefault -> HsDefault)
-> Ord HsDefault
HsDefault -> HsDefault -> Bool
HsDefault -> HsDefault -> Ordering
HsDefault -> HsDefault -> HsDefault
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: HsDefault -> HsDefault -> HsDefault
$cmin :: HsDefault -> HsDefault -> HsDefault
max :: HsDefault -> HsDefault -> HsDefault
$cmax :: HsDefault -> HsDefault -> HsDefault
>= :: HsDefault -> HsDefault -> Bool
$c>= :: HsDefault -> HsDefault -> Bool
> :: HsDefault -> HsDefault -> Bool
$c> :: HsDefault -> HsDefault -> Bool
<= :: HsDefault -> HsDefault -> Bool
$c<= :: HsDefault -> HsDefault -> Bool
< :: HsDefault -> HsDefault -> Bool
$c< :: HsDefault -> HsDefault -> Bool
compare :: HsDefault -> HsDefault -> Ordering
$ccompare :: HsDefault -> HsDefault -> Ordering
$cp1Ord :: Eq HsDefault
Ord,Typeable HsDefault
DataType
Constr
Typeable HsDefault
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsDefault -> c HsDefault)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsDefault)
-> (HsDefault -> Constr)
-> (HsDefault -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsDefault))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDefault))
-> ((forall b. Data b => b -> b) -> HsDefault -> HsDefault)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsDefault -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsDefault -> r)
-> (forall u. (forall d. Data d => d -> u) -> HsDefault -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> HsDefault -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault)
-> Data HsDefault
HsDefault -> DataType
HsDefault -> Constr
(forall b. Data b => b -> b) -> HsDefault -> HsDefault
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDefault -> c HsDefault
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDefault
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HsDefault -> u
forall u. (forall d. Data d => d -> u) -> HsDefault -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDefault
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDefault -> c HsDefault
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsDefault)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDefault)
$cHsDef'Enum :: Constr
$cHsDef'Integer :: Constr
$cHsDef'RealFloat :: Constr
$cHsDef'ByteString :: Constr
$cHsDef'Bool :: Constr
$tHsDefault :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
gmapMp :: (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
gmapM :: (forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsDefault -> m HsDefault
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDefault -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsDefault -> u
gmapQ :: (forall d. Data d => d -> u) -> HsDefault -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsDefault -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsDefault -> r
gmapT :: (forall b. Data b => b -> b) -> HsDefault -> HsDefault
$cgmapT :: (forall b. Data b => b -> b) -> HsDefault -> HsDefault
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDefault)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDefault)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsDefault)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsDefault)
dataTypeOf :: HsDefault -> DataType
$cdataTypeOf :: HsDefault -> DataType
toConstr :: HsDefault -> Constr
$ctoConstr :: HsDefault -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDefault
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsDefault
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDefault -> c HsDefault
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsDefault -> c HsDefault
$cp1Data :: Typeable HsDefault
Data,Typeable)

-- | 'SomeRealFloat' projects Double/Float to Rational or a special IEEE type.
-- This is needed to track protobuf-2.3.0 which allows nan and inf and -inf default values.
data SomeRealFloat = SRF'Rational Rational | SRF'nan | SRF'ninf | SRF'inf
  deriving (Int -> SomeRealFloat -> ShowS
[SomeRealFloat] -> ShowS
SomeRealFloat -> String
(Int -> SomeRealFloat -> ShowS)
-> (SomeRealFloat -> String)
-> ([SomeRealFloat] -> ShowS)
-> Show SomeRealFloat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SomeRealFloat] -> ShowS
$cshowList :: [SomeRealFloat] -> ShowS
show :: SomeRealFloat -> String
$cshow :: SomeRealFloat -> String
showsPrec :: Int -> SomeRealFloat -> ShowS
$cshowsPrec :: Int -> SomeRealFloat -> ShowS
Show,ReadPrec [SomeRealFloat]
ReadPrec SomeRealFloat
Int -> ReadS SomeRealFloat
ReadS [SomeRealFloat]
(Int -> ReadS SomeRealFloat)
-> ReadS [SomeRealFloat]
-> ReadPrec SomeRealFloat
-> ReadPrec [SomeRealFloat]
-> Read SomeRealFloat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SomeRealFloat]
$creadListPrec :: ReadPrec [SomeRealFloat]
readPrec :: ReadPrec SomeRealFloat
$creadPrec :: ReadPrec SomeRealFloat
readList :: ReadS [SomeRealFloat]
$creadList :: ReadS [SomeRealFloat]
readsPrec :: Int -> ReadS SomeRealFloat
$creadsPrec :: Int -> ReadS SomeRealFloat
Read,SomeRealFloat -> SomeRealFloat -> Bool
(SomeRealFloat -> SomeRealFloat -> Bool)
-> (SomeRealFloat -> SomeRealFloat -> Bool) -> Eq SomeRealFloat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SomeRealFloat -> SomeRealFloat -> Bool
$c/= :: SomeRealFloat -> SomeRealFloat -> Bool
== :: SomeRealFloat -> SomeRealFloat -> Bool
$c== :: SomeRealFloat -> SomeRealFloat -> Bool
Eq,Eq SomeRealFloat
Eq SomeRealFloat
-> (SomeRealFloat -> SomeRealFloat -> Ordering)
-> (SomeRealFloat -> SomeRealFloat -> Bool)
-> (SomeRealFloat -> SomeRealFloat -> Bool)
-> (SomeRealFloat -> SomeRealFloat -> Bool)
-> (SomeRealFloat -> SomeRealFloat -> Bool)
-> (SomeRealFloat -> SomeRealFloat -> SomeRealFloat)
-> (SomeRealFloat -> SomeRealFloat -> SomeRealFloat)
-> Ord SomeRealFloat
SomeRealFloat -> SomeRealFloat -> Bool
SomeRealFloat -> SomeRealFloat -> Ordering
SomeRealFloat -> SomeRealFloat -> SomeRealFloat
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SomeRealFloat -> SomeRealFloat -> SomeRealFloat
$cmin :: SomeRealFloat -> SomeRealFloat -> SomeRealFloat
max :: SomeRealFloat -> SomeRealFloat -> SomeRealFloat
$cmax :: SomeRealFloat -> SomeRealFloat -> SomeRealFloat
>= :: SomeRealFloat -> SomeRealFloat -> Bool
$c>= :: SomeRealFloat -> SomeRealFloat -> Bool
> :: SomeRealFloat -> SomeRealFloat -> Bool
$c> :: SomeRealFloat -> SomeRealFloat -> Bool
<= :: SomeRealFloat -> SomeRealFloat -> Bool
$c<= :: SomeRealFloat -> SomeRealFloat -> Bool
< :: SomeRealFloat -> SomeRealFloat -> Bool
$c< :: SomeRealFloat -> SomeRealFloat -> Bool
compare :: SomeRealFloat -> SomeRealFloat -> Ordering
$ccompare :: SomeRealFloat -> SomeRealFloat -> Ordering
$cp1Ord :: Eq SomeRealFloat
Ord,Typeable SomeRealFloat
DataType
Constr
Typeable SomeRealFloat
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SomeRealFloat -> c SomeRealFloat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SomeRealFloat)
-> (SomeRealFloat -> Constr)
-> (SomeRealFloat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SomeRealFloat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SomeRealFloat))
-> ((forall b. Data b => b -> b) -> SomeRealFloat -> SomeRealFloat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r)
-> (forall u. (forall d. Data d => d -> u) -> SomeRealFloat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SomeRealFloat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat)
-> Data SomeRealFloat
SomeRealFloat -> DataType
SomeRealFloat -> Constr
(forall b. Data b => b -> b) -> SomeRealFloat -> SomeRealFloat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SomeRealFloat -> c SomeRealFloat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SomeRealFloat
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SomeRealFloat -> u
forall u. (forall d. Data d => d -> u) -> SomeRealFloat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SomeRealFloat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SomeRealFloat -> c SomeRealFloat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SomeRealFloat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SomeRealFloat)
$cSRF'inf :: Constr
$cSRF'ninf :: Constr
$cSRF'nan :: Constr
$cSRF'Rational :: Constr
$tSomeRealFloat :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
gmapMp :: (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
gmapM :: (forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SomeRealFloat -> m SomeRealFloat
gmapQi :: Int -> (forall d. Data d => d -> u) -> SomeRealFloat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SomeRealFloat -> u
gmapQ :: (forall d. Data d => d -> u) -> SomeRealFloat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SomeRealFloat -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SomeRealFloat -> r
gmapT :: (forall b. Data b => b -> b) -> SomeRealFloat -> SomeRealFloat
$cgmapT :: (forall b. Data b => b -> b) -> SomeRealFloat -> SomeRealFloat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SomeRealFloat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SomeRealFloat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SomeRealFloat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SomeRealFloat)
dataTypeOf :: SomeRealFloat -> DataType
$cdataTypeOf :: SomeRealFloat -> DataType
toConstr :: SomeRealFloat -> Constr
$ctoConstr :: SomeRealFloat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SomeRealFloat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SomeRealFloat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SomeRealFloat -> c SomeRealFloat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SomeRealFloat -> c SomeRealFloat
$cp1Data :: Typeable SomeRealFloat
Data,Typeable)

toRF :: (RealFloat a, Fractional a) => SomeRealFloat -> a
toRF :: SomeRealFloat -> a
toRF (SRF'Rational Rational
r) = Rational -> a
forall a. Fractional a => Rational -> a
fromRational Rational
r
toRF SomeRealFloat
SRF'nan = (a
0a -> a -> a
forall a. Fractional a => a -> a -> a
/a
0)
toRF SomeRealFloat
SRF'ninf = (-a
1a -> a -> a
forall a. Fractional a => a -> a -> a
/a
0)
toRF SomeRealFloat
SRF'inf = (a
1a -> a -> a
forall a. Fractional a => a -> a -> a
/a
0)

fromRF :: (RealFloat a, Fractional a) => a -> SomeRealFloat
fromRF :: a -> SomeRealFloat
fromRF a
x | a -> Bool
forall a. RealFloat a => a -> Bool
isNaN a
x = SomeRealFloat
SRF'nan
         | a -> Bool
forall a. RealFloat a => a -> Bool
isInfinite a
x = if a
0 a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
x then SomeRealFloat
SRF'inf else SomeRealFloat
SRF'ninf
         | Bool
otherwise = Rational -> SomeRealFloat
SRF'Rational (a -> Rational
forall a. Real a => a -> Rational
toRational a
x)

data OneofInfo = OneofInfo { OneofInfo -> ProtoName
oneofName :: ProtoName
                           , OneofInfo -> ProtoFName
oneofFName :: ProtoFName  
                           , OneofInfo -> [String]
oneofFilePath :: [FilePath]
                           , OneofInfo -> Seq KeyInfo
oneofFields :: Seq (ProtoName,FieldInfo)
                           , OneofInfo -> Bool
oneofMakeLenses :: Bool
                           }
  deriving (Int -> OneofInfo -> ShowS
[OneofInfo] -> ShowS
OneofInfo -> String
(Int -> OneofInfo -> ShowS)
-> (OneofInfo -> String)
-> ([OneofInfo] -> ShowS)
-> Show OneofInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OneofInfo] -> ShowS
$cshowList :: [OneofInfo] -> ShowS
show :: OneofInfo -> String
$cshow :: OneofInfo -> String
showsPrec :: Int -> OneofInfo -> ShowS
$cshowsPrec :: Int -> OneofInfo -> ShowS
Show,ReadPrec [OneofInfo]
ReadPrec OneofInfo
Int -> ReadS OneofInfo
ReadS [OneofInfo]
(Int -> ReadS OneofInfo)
-> ReadS [OneofInfo]
-> ReadPrec OneofInfo
-> ReadPrec [OneofInfo]
-> Read OneofInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OneofInfo]
$creadListPrec :: ReadPrec [OneofInfo]
readPrec :: ReadPrec OneofInfo
$creadPrec :: ReadPrec OneofInfo
readList :: ReadS [OneofInfo]
$creadList :: ReadS [OneofInfo]
readsPrec :: Int -> ReadS OneofInfo
$creadsPrec :: Int -> ReadS OneofInfo
Read,OneofInfo -> OneofInfo -> Bool
(OneofInfo -> OneofInfo -> Bool)
-> (OneofInfo -> OneofInfo -> Bool) -> Eq OneofInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OneofInfo -> OneofInfo -> Bool
$c/= :: OneofInfo -> OneofInfo -> Bool
== :: OneofInfo -> OneofInfo -> Bool
$c== :: OneofInfo -> OneofInfo -> Bool
Eq,Eq OneofInfo
Eq OneofInfo
-> (OneofInfo -> OneofInfo -> Ordering)
-> (OneofInfo -> OneofInfo -> Bool)
-> (OneofInfo -> OneofInfo -> Bool)
-> (OneofInfo -> OneofInfo -> Bool)
-> (OneofInfo -> OneofInfo -> Bool)
-> (OneofInfo -> OneofInfo -> OneofInfo)
-> (OneofInfo -> OneofInfo -> OneofInfo)
-> Ord OneofInfo
OneofInfo -> OneofInfo -> Bool
OneofInfo -> OneofInfo -> Ordering
OneofInfo -> OneofInfo -> OneofInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OneofInfo -> OneofInfo -> OneofInfo
$cmin :: OneofInfo -> OneofInfo -> OneofInfo
max :: OneofInfo -> OneofInfo -> OneofInfo
$cmax :: OneofInfo -> OneofInfo -> OneofInfo
>= :: OneofInfo -> OneofInfo -> Bool
$c>= :: OneofInfo -> OneofInfo -> Bool
> :: OneofInfo -> OneofInfo -> Bool
$c> :: OneofInfo -> OneofInfo -> Bool
<= :: OneofInfo -> OneofInfo -> Bool
$c<= :: OneofInfo -> OneofInfo -> Bool
< :: OneofInfo -> OneofInfo -> Bool
$c< :: OneofInfo -> OneofInfo -> Bool
compare :: OneofInfo -> OneofInfo -> Ordering
$ccompare :: OneofInfo -> OneofInfo -> Ordering
$cp1Ord :: Eq OneofInfo
Ord,Typeable OneofInfo
DataType
Constr
Typeable OneofInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> OneofInfo -> c OneofInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OneofInfo)
-> (OneofInfo -> Constr)
-> (OneofInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OneofInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OneofInfo))
-> ((forall b. Data b => b -> b) -> OneofInfo -> OneofInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OneofInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OneofInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> OneofInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OneofInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo)
-> Data OneofInfo
OneofInfo -> DataType
OneofInfo -> Constr
(forall b. Data b => b -> b) -> OneofInfo -> OneofInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OneofInfo -> c OneofInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OneofInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OneofInfo -> u
forall u. (forall d. Data d => d -> u) -> OneofInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OneofInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OneofInfo -> c OneofInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OneofInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OneofInfo)
$cOneofInfo :: Constr
$tOneofInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
gmapMp :: (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
gmapM :: (forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OneofInfo -> m OneofInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> OneofInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OneofInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> OneofInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OneofInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OneofInfo -> r
gmapT :: (forall b. Data b => b -> b) -> OneofInfo -> OneofInfo
$cgmapT :: (forall b. Data b => b -> b) -> OneofInfo -> OneofInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OneofInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OneofInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OneofInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OneofInfo)
dataTypeOf :: OneofInfo -> DataType
$cdataTypeOf :: OneofInfo -> DataType
toConstr :: OneofInfo -> Constr
$ctoConstr :: OneofInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OneofInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OneofInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OneofInfo -> c OneofInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OneofInfo -> c OneofInfo
$cp1Data :: Typeable OneofInfo
Data,Typeable)

data EnumInfo = EnumInfo { EnumInfo -> ProtoName
enumName :: ProtoName
                         , EnumInfo -> [String]
enumFilePath :: [FilePath]
                         , EnumInfo -> [(EnumCode, String)]
enumValues :: [(EnumCode,String)] -- ^ The String is the Haskell name to write into the generated source files
                         , EnumInfo -> Bool
enumJsonInstances :: Bool
                         }
  deriving (Int -> EnumInfo -> ShowS
[EnumInfo] -> ShowS
EnumInfo -> String
(Int -> EnumInfo -> ShowS)
-> (EnumInfo -> String) -> ([EnumInfo] -> ShowS) -> Show EnumInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumInfo] -> ShowS
$cshowList :: [EnumInfo] -> ShowS
show :: EnumInfo -> String
$cshow :: EnumInfo -> String
showsPrec :: Int -> EnumInfo -> ShowS
$cshowsPrec :: Int -> EnumInfo -> ShowS
Show,ReadPrec [EnumInfo]
ReadPrec EnumInfo
Int -> ReadS EnumInfo
ReadS [EnumInfo]
(Int -> ReadS EnumInfo)
-> ReadS [EnumInfo]
-> ReadPrec EnumInfo
-> ReadPrec [EnumInfo]
-> Read EnumInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnumInfo]
$creadListPrec :: ReadPrec [EnumInfo]
readPrec :: ReadPrec EnumInfo
$creadPrec :: ReadPrec EnumInfo
readList :: ReadS [EnumInfo]
$creadList :: ReadS [EnumInfo]
readsPrec :: Int -> ReadS EnumInfo
$creadsPrec :: Int -> ReadS EnumInfo
Read,EnumInfo -> EnumInfo -> Bool
(EnumInfo -> EnumInfo -> Bool)
-> (EnumInfo -> EnumInfo -> Bool) -> Eq EnumInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumInfo -> EnumInfo -> Bool
$c/= :: EnumInfo -> EnumInfo -> Bool
== :: EnumInfo -> EnumInfo -> Bool
$c== :: EnumInfo -> EnumInfo -> Bool
Eq,Eq EnumInfo
Eq EnumInfo
-> (EnumInfo -> EnumInfo -> Ordering)
-> (EnumInfo -> EnumInfo -> Bool)
-> (EnumInfo -> EnumInfo -> Bool)
-> (EnumInfo -> EnumInfo -> Bool)
-> (EnumInfo -> EnumInfo -> Bool)
-> (EnumInfo -> EnumInfo -> EnumInfo)
-> (EnumInfo -> EnumInfo -> EnumInfo)
-> Ord EnumInfo
EnumInfo -> EnumInfo -> Bool
EnumInfo -> EnumInfo -> Ordering
EnumInfo -> EnumInfo -> EnumInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EnumInfo -> EnumInfo -> EnumInfo
$cmin :: EnumInfo -> EnumInfo -> EnumInfo
max :: EnumInfo -> EnumInfo -> EnumInfo
$cmax :: EnumInfo -> EnumInfo -> EnumInfo
>= :: EnumInfo -> EnumInfo -> Bool
$c>= :: EnumInfo -> EnumInfo -> Bool
> :: EnumInfo -> EnumInfo -> Bool
$c> :: EnumInfo -> EnumInfo -> Bool
<= :: EnumInfo -> EnumInfo -> Bool
$c<= :: EnumInfo -> EnumInfo -> Bool
< :: EnumInfo -> EnumInfo -> Bool
$c< :: EnumInfo -> EnumInfo -> Bool
compare :: EnumInfo -> EnumInfo -> Ordering
$ccompare :: EnumInfo -> EnumInfo -> Ordering
$cp1Ord :: Eq EnumInfo
Ord,Typeable EnumInfo
DataType
Constr
Typeable EnumInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EnumInfo -> c EnumInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumInfo)
-> (EnumInfo -> Constr)
-> (EnumInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumInfo))
-> ((forall b. Data b => b -> b) -> EnumInfo -> EnumInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnumInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EnumInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo)
-> Data EnumInfo
EnumInfo -> DataType
EnumInfo -> Constr
(forall b. Data b => b -> b) -> EnumInfo -> EnumInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumInfo -> c EnumInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EnumInfo -> u
forall u. (forall d. Data d => d -> u) -> EnumInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumInfo -> c EnumInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumInfo)
$cEnumInfo :: Constr
$tEnumInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
gmapMp :: (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
gmapM :: (forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumInfo -> m EnumInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> EnumInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumInfo -> r
gmapT :: (forall b. Data b => b -> b) -> EnumInfo -> EnumInfo
$cgmapT :: (forall b. Data b => b -> b) -> EnumInfo -> EnumInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnumInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumInfo)
dataTypeOf :: EnumInfo -> DataType
$cdataTypeOf :: EnumInfo -> DataType
toConstr :: EnumInfo -> Constr
$ctoConstr :: EnumInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumInfo -> c EnumInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumInfo -> c EnumInfo
$cp1Data :: Typeable EnumInfo
Data,Typeable)

type EnumInfoApp e = [(EnumCode,String,e)]


class ReflectEnum e where
  reflectEnum :: EnumInfoApp e
  reflectEnumInfo :: e -> EnumInfo            -- ^ Must not inspect argument
  parentOfEnum :: e -> Maybe DescriptorInfo   -- ^ Must not inspect argument
  parentOfEnum e
_ = Maybe DescriptorInfo
forall a. Maybe a
Nothing

class ReflectDescriptor m where
  -- | This is obtained via 'read' on the stored 'show' output of the 'DescriptorInfo' in
  -- the module file. It is used in getting messages from the wire.
  -- 
  -- Must not inspect argument
  getMessageInfo :: m -> GetMessageInfo
  getMessageInfo m
x = GetMessageInfo
cached
    where cached :: GetMessageInfo
cached = DescriptorInfo -> GetMessageInfo
makeMessageInfo (m -> DescriptorInfo
forall m. ReflectDescriptor m => m -> DescriptorInfo
reflectDescriptorInfo (m
forall a. HasCallStack => a
undefined m -> m -> m
forall a. a -> a -> a
`asTypeOf` m
x))
          makeMessageInfo :: DescriptorInfo -> GetMessageInfo
          makeMessageInfo :: DescriptorInfo -> GetMessageInfo
makeMessageInfo DescriptorInfo
di = GetMessageInfo :: Set WireTag -> Set WireTag -> GetMessageInfo
GetMessageInfo { requiredTags :: Set WireTag
requiredTags = [WireTag] -> Set WireTag
forall a. [a] -> Set a
Set.fromDistinctAscList ([WireTag] -> Set WireTag)
-> ([WireTag] -> [WireTag]) -> [WireTag] -> Set WireTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [WireTag] -> [WireTag]
forall a. Ord a => [a] -> [a]
sort ([WireTag] -> Set WireTag) -> [WireTag] -> Set WireTag
forall a b. (a -> b) -> a -> b
$
                                                  [ FieldInfo -> WireTag
wireTag FieldInfo
f | FieldInfo
f <- Seq FieldInfo -> [FieldInfo]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (DescriptorInfo -> Seq FieldInfo
fields DescriptorInfo
di), FieldInfo -> Bool
isRequired FieldInfo
f]
                                              , allowedTags :: Set WireTag
allowedTags = [WireTag] -> Set WireTag
forall a. [a] -> Set a
Set.fromDistinctAscList ([WireTag] -> Set WireTag)
-> ([WireTag] -> [WireTag]) -> [WireTag] -> Set WireTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [WireTag] -> [WireTag]
forall a. Ord a => [a] -> [a]
sort ([WireTag] -> Set WireTag) -> [WireTag] -> Set WireTag
forall a b. (a -> b) -> a -> b
$
                                                  [ FieldInfo -> WireTag
wireTag FieldInfo
f | FieldInfo
f <- Seq FieldInfo -> [FieldInfo]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (DescriptorInfo -> Seq FieldInfo
fields DescriptorInfo
di)] [WireTag] -> [WireTag] -> [WireTag]
forall a. [a] -> [a] -> [a]
++
                                                  [ FieldInfo -> WireTag
wireTag FieldInfo
f | FieldInfo
f <- Seq FieldInfo -> [FieldInfo]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (DescriptorInfo -> Seq FieldInfo
knownKeys DescriptorInfo
di)]
                                              }
  reflectDescriptorInfo :: m -> DescriptorInfo    -- ^ Must not inspect argument