Safe Haskell	None
Language	Haskell98

Text.ProtocolBuffers.Reflections

Description

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.

Synopsis

Documentation

data ProtoName Source

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'] .

Constructors

ProtoName
Fields protobufName :: FIName Utf8 fully qualified name using "package" prefix (no mangling) haskellPrefix :: [MName String] Haskell specific prefix to module hierarchy (e.g. Text.Foo) parentModule :: [MName String] .proto specified namespace (like Com.Google.Bar) baseName :: MName String

Instances

Eq ProtoName
Data ProtoName
Ord ProtoName
Read ProtoName
Show ProtoName
Typeable * ProtoName

data ProtoFName Source

Constructors

ProtoFName
Fields protobufName' :: FIName Utf8 fully qualified name using "package" prefix (no mangling) haskellPrefix' :: [MName String] Haskell specific prefix to module hierarchy (e.g. Text.Foo) parentModule' :: [MName String] .proto specified namespace (like Com.Google.Bar) baseName' :: FName String

Instances

Eq ProtoFName
Data ProtoFName
Ord ProtoFName
Read ProtoFName
Show ProtoFName
Typeable * ProtoFName

data ProtoInfo Source

Constructors

ProtoInfo
Fields protoMod :: ProtoName blank protobufName, maybe blank haskellPrefix and/or parentModule protoFilePath :: [FilePath] path to haskell module protoSource :: FilePath filename without path of .proto file extensionKeys :: Seq KeyInfo top level keys messages :: [DescriptorInfo] all messages and groups enums :: [EnumInfo] all enums knownKeyMap :: Map ProtoName (Seq FieldInfo)

Instances

Eq ProtoInfo
Data ProtoInfo
Ord ProtoInfo
Read ProtoInfo
Show ProtoInfo
Typeable * ProtoInfo

data DescriptorInfo Source

Constructors

DescriptorInfo
Fields descName :: ProtoName descFilePath :: [FilePath] isGroup :: Bool fields :: Seq FieldInfo keys :: Seq KeyInfo extRanges :: [(FieldId, FieldId)] knownKeys :: Seq FieldInfo storeUnknown :: Bool lazyFields :: Bool

Instances

Eq DescriptorInfo
Data DescriptorInfo
Ord DescriptorInfo
Read DescriptorInfo
Show DescriptorInfo
Typeable * DescriptorInfo

data FieldInfo Source

Constructors

FieldInfo

Fields

fieldName :: ProtoFName
fieldNumber :: FieldId
wireTag :: WireTag: Used for writing and reading if packedTag is Nothing
packedTag :: Maybe (WireTag, WireTag): used for reading when Just {} instead of wireTag
wireTagLength :: WireSize: Bytes required in the Varint formatted wireTag
isPacked :: Bool
isRequired :: Bool
canRepeat :: Bool: True if repeated is the field type
mightPack :: Bool: True if packed would be valid for this field type
typeCode :: FieldType: fromEnum of Text.DescriptorProtos.FieldDescriptorProto.Type
typeName :: Maybe ProtoName: Set for Messages,Groups,and Enums
hsRawDefault :: Maybe ByteString: crappy, but not escaped, thing
hsDefault :: Maybe HsDefault: nice parsed thing

Instances

Eq FieldInfo
Data FieldInfo
Ord FieldInfo
Read FieldInfo
Show FieldInfo
Typeable * FieldInfo

type KeyInfo = (ProtoName, FieldInfo) Source

data HsDefault Source

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.

Constructors

HsDef'Bool Bool
HsDef'ByteString ByteString
HsDef'RealFloat SomeRealFloat
HsDef'Integer Integer
HsDef'Enum String

Instances

Eq HsDefault
Data HsDefault
Ord HsDefault
Read HsDefault
Show HsDefault
Typeable * HsDefault

data SomeRealFloat Source

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.

Constructors

SRF'Rational Rational
SRF'nan
SRF'ninf
SRF'inf

Instances

Eq SomeRealFloat
Data SomeRealFloat
Ord SomeRealFloat
Read SomeRealFloat
Show SomeRealFloat
Typeable * SomeRealFloat

data EnumInfo Source

Constructors

EnumInfo
Fields enumName :: ProtoName enumFilePath :: [FilePath] enumValues :: [(EnumCode, String)] The String is the Haskell name to write into the generated source files

Instances

Eq EnumInfo
Data EnumInfo
Ord EnumInfo
Read EnumInfo
Show EnumInfo
Typeable * EnumInfo

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

class ReflectDescriptor m where Source

Minimal complete definition

reflectDescriptorInfo

Methods

getMessageInfo :: m -> GetMessageInfo Source

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

reflectDescriptorInfo Source

Arguments

:: m
-> DescriptorInfo	Must not inspect argument

class ReflectEnum e where Source

Minimal complete definition

reflectEnum, reflectEnumInfo

Methods

reflectEnum :: EnumInfoApp e Source

reflectEnumInfo Source

Arguments

:: e
-> EnumInfo	Must not inspect argument

parentOfEnum Source

Arguments

:: e
-> Maybe DescriptorInfo	Must not inspect argument

data GetMessageInfo Source

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.

Constructors

GetMessageInfo
Fields requiredTags :: Set WireTag allowedTags :: Set WireTag

Instances

Eq GetMessageInfo
Data GetMessageInfo
Ord GetMessageInfo
Read GetMessageInfo
Show GetMessageInfo
Typeable * GetMessageInfo

makePNF :: ByteString -> [String] -> [String] -> String -> ProtoName Source

makePNF is used by the generated code to create a ProtoName with less newtype noise.

toRF :: (RealFloat a, Fractional a) => SomeRealFloat -> a Source

fromRF :: (RealFloat a, Fractional a) => a -> SomeRealFloat Source