Safe Haskell | None |
---|---|
Language | Haskell2010 |
Parse an XSD into types with the ability to resolve references.
Synopsis
- parseFile :: FilePath -> IO Schema
- loadXsdSchema :: FilePath -> IO Schema
- schemaParser :: XParser m => m Schema
- namespaceSchema :: String -> Schema -> Schema
- qnParser :: Parsec String m QN
- attrParser :: Parsec String m String
- parsec :: Stream s Identity t => Parsec s () a -> s -> a
- qn :: String -> QN
- anySimpleTypeName :: QN
- class Typeable a => Resolvable a where
- refResolve :: Resolvable r => String -> Getting (Map QN r) Schema (Map QN r) -> Schema -> Ref r -> Ref r
- data Ref a
- = Unresolved {
- _unresolved :: !QN
- | Resolved { }
- | Final
- = Unresolved {
- unresolved :: forall a. Traversal' (Ref a) QN
- resolved :: forall a. Traversal' (Ref a) QN
- refvalue :: forall a a. Traversal (Ref a) (Ref a) a a
- data Schema = Schema {
- _simpleTypes :: !(Map QN SimpleType)
- _complexTypes :: !(Map QN ComplexType)
- _groups :: !(Map QN Group)
- _attributeGroups :: !(Map QN AttributeGroup)
- _elements :: !(Map QN Element)
- _attributes :: !(Map QN Attribute)
- simpleTypes :: Lens' Schema (Map QN SimpleType)
- complexTypes :: Lens' Schema (Map QN ComplexType)
- groups :: Lens' Schema (Map QN Group)
- attributeGroups :: Lens' Schema (Map QN AttributeGroup)
- elements :: Lens' Schema (Map QN Element)
- attributes :: Lens' Schema (Map QN Attribute)
- data QN = QN {}
- qLocal :: Lens' QN String
- qPrefix :: Lens' QN (Maybe String)
- data SimpleType
- simpleTypeName :: Lens' SimpleType (Maybe QN)
- simpleTypeRestriction :: Traversal' SimpleType SimpleRestriction
- simpleTypeUnion :: Traversal' SimpleType Union
- simpleTypeDoc :: Lens' SimpleType (Maybe Documentation)
- data Bound a
- data SimpleRestriction = SimpleRestriction {
- _simpleRestrictBase :: !(Ref SimpleType)
- _simpleRestrictEnums :: ![String]
- _simpleRestrictMin :: !(Maybe (Bound String))
- _simpleRestrictMax :: !(Maybe (Bound String))
- _simpleRestrictPattern :: !(Maybe String)
- simpleRestrictBase :: Lens' SimpleRestriction (Ref SimpleType)
- simpleRestrictEnums :: Lens' SimpleRestriction [String]
- simpleRestrictMin :: Lens' SimpleRestriction (Maybe (Bound String))
- simpleRestrictMax :: Lens' SimpleRestriction (Maybe (Bound String))
- simpleRestrictPattern :: Lens' SimpleRestriction (Maybe String)
- data Union = Union {
- _unionMemberTypes :: ![Ref SimpleType]
- _unionSimpleTypes :: ![SimpleType]
- unionMemberTypes :: Lens' Union [Ref SimpleType]
- unionSimpleTypes :: Lens' Union [SimpleType]
- data Attribute
- = AttributeType {
- _attrName :: !QN
- _attrType :: !(Ref SimpleType)
- _attrUse :: !Use
- _attrDefault :: !(Maybe String)
- | AttributeRef { }
- | AttributeSimpleType {
- _attrName :: !QN
- _attrSimpleType :: SimpleType
- = AttributeType {
- attrName :: Traversal' Attribute QN
- attrType :: Traversal' Attribute (Ref SimpleType)
- attrUse :: Traversal' Attribute Use
- attrDefault :: Traversal' Attribute (Maybe String)
- attrRef :: Traversal' Attribute (Ref Attribute)
- attrSimpleType :: Traversal' Attribute SimpleType
- data Use
- data AttributeGroup
- = AttributeGroup { }
- | AttributeGroupRef {
- _attrGroupRef :: !(Ref AttributeGroup)
- attrGroupName :: Traversal' AttributeGroup QN
- attrGroupAttributes :: Traversal' AttributeGroup Attributes
- attrGroupRef :: Traversal' AttributeGroup (Ref AttributeGroup)
- attrGroupDoc :: Traversal' AttributeGroup (Maybe Documentation)
- data Attributes = Attributes {}
- attrsAttributes :: Lens' Attributes [Attribute]
- attrsAttributeGroups :: Lens' Attributes [AttributeGroup]
- data Occurs = Occurs {
- _occursMin :: !(Maybe String)
- _occursMax :: !(Maybe String)
- occursMin :: Lens' Occurs (Maybe String)
- occursMax :: Lens' Occurs (Maybe String)
- data Element
- = ElementType {
- _elementName :: !QN
- _elementType :: !(Ref (Either ComplexType SimpleType))
- _elementOccurs :: !Occurs
- _elementDoc :: Maybe Documentation
- | ElementSimple { }
- | ElementComplex { }
- | ElementRef {
- _elementRef :: !(Ref Element)
- _elementOccurs :: !Occurs
- = ElementType {
- elementName :: Traversal' Element QN
- elementType :: Traversal' Element (Ref (Either ComplexType SimpleType))
- elementOccurs :: Lens' Element Occurs
- elementSimple :: Traversal' Element SimpleType
- elementComplex :: Traversal' Element ComplexType
- elementRef :: Traversal' Element (Ref Element)
- elementDoc :: Traversal' Element (Maybe Documentation)
- data ComplexType
- = ComplexTypeSimple { }
- | ComplexTypeComplex { }
- | ComplexTypeCompositor { }
- complexTypeName :: Lens' ComplexType (Maybe QN)
- complexSimpleContent :: Traversal' ComplexType SimpleContent
- complexComplexContent :: Traversal' ComplexType ComplexContent
- complexCompositor :: Traversal' ComplexType (Maybe Compositor)
- complexAttributes :: Traversal' ComplexType Attributes
- complexTypeDoc :: Lens' ComplexType (Maybe Documentation)
- data SimpleContent = SimpleContentExtension {}
- simpleContentBase :: Lens' SimpleContent (Ref SimpleType)
- simpleContentAttributes :: Lens' SimpleContent Attributes
- data ComplexContent = ComplexContentExtension {}
- complexContentBase :: Lens' ComplexContent (Ref ComplexType)
- complexContentAttributes :: Lens' ComplexContent Attributes
- complexContentCompositor :: Lens' ComplexContent (Maybe Compositor)
- data Compositor
- = CompositorGroup {
- _compGroup :: !Group
- | CompositorChoice {
- _compChoice :: !Choice
- | CompositorSequence { }
- = CompositorGroup {
- compGroup :: Traversal' Compositor Group
- compChoice :: Traversal' Compositor Choice
- compSequence :: Traversal' Compositor Sequence
- data Group
- = GroupChoice {
- _groupName :: !(Maybe QN)
- _groupOccurs :: !Occurs
- _groupChoice :: !Choice
- _groupDoc :: Maybe Documentation
- | GroupSequence {
- _groupName :: !(Maybe QN)
- _groupOccurs :: !Occurs
- _groupSequence :: !Sequence
- _groupDoc :: Maybe Documentation
- | GroupRef {
- _groupRef :: !(Ref Group)
- _groupOccurs :: !Occurs
- = GroupChoice {
- groupName :: Traversal' Group (Maybe QN)
- groupOccurs :: Lens' Group Occurs
- groupChoice :: Traversal' Group Choice
- groupSequence :: Traversal' Group Sequence
- groupRef :: Traversal' Group (Ref Group)
- groupDoc :: Traversal' Group (Maybe Documentation)
- data Particle
- = PartElement {
- _partElement :: !Element
- | PartGroup {
- _partGroup :: !Group
- | PartChoice {
- _partChoice :: !Choice
- | PartSequence { }
- = PartElement {
- partElement :: Traversal' Particle Element
- partGroup :: Traversal' Particle Group
- partChoice :: Traversal' Particle Choice
- partSequence :: Traversal' Particle Sequence
- data Choice = Choice {
- _choiceOccurs :: !Occurs
- _choiceParticles :: ![Particle]
- choiceOccurs :: Lens' Choice Occurs
- choiceParticles :: Lens' Choice [Particle]
- data Sequence = Sequence {
- _sequenceOccurs :: !Occurs
- _sequenceParticles :: ![Particle]
- sequenceOccurs :: Lens' Sequence Occurs
- sequenceParticles :: Lens' Sequence [Particle]
- newtype Documentation = Documentation String
Parsers and utilities
schemaParser :: XParser m => m Schema Source #
Main parser.
namespaceSchema :: String -> Schema -> Schema Source #
Adjust top-level names to have supplied prefix.
anySimpleTypeName :: QN Source #
XML Schema "anySimpleType" (ie, built-ins like string, double etc).
Type References
class Typeable a => Resolvable a where Source #
Resolvable indicates a type has a Ref
member that it can
resolve from a top-level Schema
production.
Instances
refResolve :: Resolvable r => String -> Getting (Map QN r) Schema (Map QN r) -> Schema -> Ref r -> Ref r Source #
Schema, QNs, Refs
Model an outward XSD reference.
Unresolved | Just type name. |
| |
Resolved | Type name and resolved value. |
Final | Reserved for built-in types (string, etc) |
Instances
Eq a => Eq (Ref a) Source # | |
Data a => Data (Ref a) Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ref a -> c (Ref a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ref a) # dataTypeOf :: Ref a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ref a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ref a)) # gmapT :: (forall b. Data b => b -> b) -> Ref a -> Ref a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ref a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ref a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ref a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ref a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) # | |
Show (Ref a) Source # | |
Resolvable (Ref (Either ComplexType SimpleType)) Source # | |
Defined in Fadno.Xml.ParseXsd resolve :: Schema -> Ref (Either ComplexType SimpleType) -> Ref (Either ComplexType SimpleType) Source # | |
Resolvable (Ref Group) Source # | |
Resolvable (Ref ComplexType) Source # | |
Defined in Fadno.Xml.ParseXsd resolve :: Schema -> Ref ComplexType -> Ref ComplexType Source # | |
Resolvable (Ref Element) Source # | |
Resolvable (Ref AttributeGroup) Source # | |
Defined in Fadno.Xml.ParseXsd resolve :: Schema -> Ref AttributeGroup -> Ref AttributeGroup Source # | |
Resolvable (Ref Attribute) Source # | |
Resolvable (Ref SimpleType) Source # | |
Defined in Fadno.Xml.ParseXsd resolve :: Schema -> Ref SimpleType -> Ref SimpleType Source # |
unresolved :: forall a. Traversal' (Ref a) QN Source #
Schema type, mapping top-level productions to qnames.
Schema | |
|
Instances
Eq Schema Source # | |
Data Schema Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Schema -> c Schema # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Schema # toConstr :: Schema -> Constr # dataTypeOf :: Schema -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Schema) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Schema) # gmapT :: (forall b. Data b => b -> b) -> Schema -> Schema # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Schema -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Schema -> r # gmapQ :: (forall d. Data d => d -> u) -> Schema -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Schema -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Schema -> m Schema # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Schema -> m Schema # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Schema -> m Schema # | |
Show Schema Source # | |
Semigroup Schema Source # | |
Monoid Schema Source # | |
simpleTypes :: Lens' Schema (Map QN SimpleType) Source #
complexTypes :: Lens' Schema (Map QN ComplexType) Source #
QName type.
Instances
Eq QN Source # | |
Data QN Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QN -> c QN # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QN # dataTypeOf :: QN -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QN) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QN) # gmapT :: (forall b. Data b => b -> b) -> QN -> QN # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QN -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QN -> r # gmapQ :: (forall d. Data d => d -> u) -> QN -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QN -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QN -> m QN # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QN -> m QN # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QN -> m QN # | |
Ord QN Source # | |
Show QN Source # | |
Productions
data SimpleType Source #
XSD simpleType production.
SimpleTypeRestrict | |
SimpleTypeUnion | |
|
Instances
simpleTypeName :: Lens' SimpleType (Maybe QN) Source #
Model min/max restrictions.
Instances
Functor Bound Source # | |
Eq a => Eq (Bound a) Source # | |
Data a => Data (Bound a) Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bound a -> c (Bound a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bound a) # toConstr :: Bound a -> Constr # dataTypeOf :: Bound a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bound a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bound a)) # gmapT :: (forall b. Data b => b -> b) -> Bound a -> Bound a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bound a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bound a -> r # gmapQ :: (forall d. Data d => d -> u) -> Bound a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bound a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bound a -> m (Bound a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bound a -> m (Bound a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bound a -> m (Bound a) # | |
Ord a => Ord (Bound a) Source # | |
Show a => Show (Bound a) Source # | |
data SimpleRestriction Source #
simple type restriction production.
SimpleRestriction | |
|
Instances
Simple type union production.
Union | |
|
Instances
Eq Union Source # | |
Data Union Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Union -> c Union # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Union # dataTypeOf :: Union -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Union) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Union) # gmapT :: (forall b. Data b => b -> b) -> Union -> Union # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Union -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Union -> r # gmapQ :: (forall d. Data d => d -> u) -> Union -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Union -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Union -> m Union # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Union -> m Union # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Union -> m Union # | |
Show Union Source # | |
Resolvable Union Source # | |
XSD attribute production.
AttributeType | |
| |
AttributeRef | |
AttributeSimpleType | |
|
Instances
Eq Attribute Source # | |
Data Attribute Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Attribute -> c Attribute # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Attribute # toConstr :: Attribute -> Constr # dataTypeOf :: Attribute -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Attribute) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute) # gmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attribute -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attribute -> r # gmapQ :: (forall d. Data d => d -> u) -> Attribute -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Attribute -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Attribute -> m Attribute # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Attribute -> m Attribute # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Attribute -> m Attribute # | |
Show Attribute Source # | |
Resolvable Attribute Source # | |
Resolvable (Ref Attribute) Source # | |
XSD "use" values.
Instances
Eq Use Source # | |
Data Use Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Use -> c Use # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Use # dataTypeOf :: Use -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Use) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Use) # gmapT :: (forall b. Data b => b -> b) -> Use -> Use # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r # gmapQ :: (forall d. Data d => d -> u) -> Use -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Use -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Use -> m Use # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Use -> m Use # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Use -> m Use # | |
Show Use Source # | |
data AttributeGroup Source #
XSD attribute-group production.
Instances
data Attributes Source #
Convenience grouping of attributes and attribute groups, which are always showing up together in xsd.
Instances
Eq Attributes Source # | |
Defined in Fadno.Xml.ParseXsd (==) :: Attributes -> Attributes -> Bool # (/=) :: Attributes -> Attributes -> Bool # | |
Data Attributes Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Attributes -> c Attributes # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Attributes # toConstr :: Attributes -> Constr # dataTypeOf :: Attributes -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Attributes) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attributes) # gmapT :: (forall b. Data b => b -> b) -> Attributes -> Attributes # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attributes -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attributes -> r # gmapQ :: (forall d. Data d => d -> u) -> Attributes -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Attributes -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Attributes -> m Attributes # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Attributes -> m Attributes # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Attributes -> m Attributes # | |
Show Attributes Source # | |
Defined in Fadno.Xml.ParseXsd showsPrec :: Int -> Attributes -> ShowS # show :: Attributes -> String # showList :: [Attributes] -> ShowS # |
"occurs-min" and "occurs-max"
Occurs | |
|
Instances
Eq Occurs Source # | |
Data Occurs Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Occurs -> c Occurs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Occurs # toConstr :: Occurs -> Constr # dataTypeOf :: Occurs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Occurs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Occurs) # gmapT :: (forall b. Data b => b -> b) -> Occurs -> Occurs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Occurs -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Occurs -> r # gmapQ :: (forall d. Data d => d -> u) -> Occurs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Occurs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Occurs -> m Occurs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Occurs -> m Occurs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Occurs -> m Occurs # | |
Show Occurs Source # | |
XSD element production.
ElementType | |
| |
ElementSimple | |
| |
ElementComplex | |
| |
ElementRef | |
|
Instances
Eq Element Source # | |
Data Element Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Element -> c Element # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Element # toConstr :: Element -> Constr # dataTypeOf :: Element -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Element) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element) # gmapT :: (forall b. Data b => b -> b) -> Element -> Element # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Element -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Element -> r # gmapQ :: (forall d. Data d => d -> u) -> Element -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Element -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Element -> m Element # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Element -> m Element # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Element -> m Element # | |
Show Element Source # | |
Resolvable Element Source # | |
Resolvable (Ref Element) Source # | |
elementRef :: Traversal' Element (Ref Element) Source #
data ComplexType Source #
XSD complexType production.
Instances
data SimpleContent Source #
simpleContent under a complex type.
Instances
data ComplexContent Source #
complexContent under a complex type. TODO: restrictions
Instances
data Compositor Source #
Compositors.
Instances
Eq Compositor Source # | |
Defined in Fadno.Xml.ParseXsd (==) :: Compositor -> Compositor -> Bool # (/=) :: Compositor -> Compositor -> Bool # | |
Data Compositor Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Compositor -> c Compositor # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Compositor # toConstr :: Compositor -> Constr # dataTypeOf :: Compositor -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Compositor) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Compositor) # gmapT :: (forall b. Data b => b -> b) -> Compositor -> Compositor # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compositor -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compositor -> r # gmapQ :: (forall d. Data d => d -> u) -> Compositor -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Compositor -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compositor -> m Compositor # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compositor -> m Compositor # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compositor -> m Compositor # | |
Show Compositor Source # | |
Defined in Fadno.Xml.ParseXsd showsPrec :: Int -> Compositor -> ShowS # show :: Compositor -> String # showList :: [Compositor] -> ShowS # |
XSD "group" production.
GroupChoice | |
| |
GroupSequence | |
| |
GroupRef | |
|
Instances
Eq Group Source # | |
Data Group Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Group -> c Group # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Group # dataTypeOf :: Group -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Group) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Group) # gmapT :: (forall b. Data b => b -> b) -> Group -> Group # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Group -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Group -> r # gmapQ :: (forall d. Data d => d -> u) -> Group -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Group -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Group -> m Group # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Group -> m Group # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Group -> m Group # | |
Show Group Source # | |
Resolvable Group Source # | |
Resolvable (Ref Group) Source # | |
Particles.
PartElement | |
| |
PartGroup | |
| |
PartChoice | |
| |
PartSequence | |
Instances
Eq Particle Source # | |
Data Particle Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Particle -> c Particle # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Particle # toConstr :: Particle -> Constr # dataTypeOf :: Particle -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Particle) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Particle) # gmapT :: (forall b. Data b => b -> b) -> Particle -> Particle # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Particle -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Particle -> r # gmapQ :: (forall d. Data d => d -> u) -> Particle -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Particle -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Particle -> m Particle # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Particle -> m Particle # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Particle -> m Particle # | |
Show Particle Source # | |
XSD choice
Choice | |
|
Instances
Eq Choice Source # | |
Data Choice Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Choice -> c Choice # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Choice # toConstr :: Choice -> Constr # dataTypeOf :: Choice -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Choice) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Choice) # gmapT :: (forall b. Data b => b -> b) -> Choice -> Choice # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Choice -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Choice -> r # gmapQ :: (forall d. Data d => d -> u) -> Choice -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Choice -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Choice -> m Choice # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice -> m Choice # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice -> m Choice # | |
Show Choice Source # | |
XSD sequence.
Sequence | |
|
Instances
Eq Sequence Source # | |
Data Sequence Source # | |
Defined in Fadno.Xml.ParseXsd gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sequence -> c Sequence # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Sequence # toConstr :: Sequence -> Constr # dataTypeOf :: Sequence -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Sequence) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sequence) # gmapT :: (forall b. Data b => b -> b) -> Sequence -> Sequence # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sequence -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sequence -> r # gmapQ :: (forall d. Data d => d -> u) -> Sequence -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sequence -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sequence -> m Sequence # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sequence -> m Sequence # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sequence -> m Sequence # | |
Show Sequence Source # | |
newtype Documentation Source #