HaXml-1.25.7: Utilities for manipulating XML documents

Text.XML.HaXml.Schema.Parse

Synopsis

# Documentation

type XsdParser a = Parser (Content Posn) a Source #

We need a Parser monad for reading from a sequence of generic XML Contents into specific datatypes that model the structure of XSD descriptions. This is a specialisation of the polyparse combinators, fixing the input token type.

(|||) :: (a -> Bool) -> (a -> Bool) -> a -> Bool Source #

Lift boolean or over predicates.

Qualify an ordinary name with the XSD namespace.

Predicate for comparing against an XSD-qualified name. (Also accepts unqualified names, but this is probably a bit too lax. Doing it right would require checking to see whether the current schema module's default namespace is XSD or not.)

posnElementWith :: (Content Posn -> Bool) -> [String] -> XsdParser (Posn, Element Posn) Source #

Get the next content element, checking that it matches some criterion given by the predicate. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.) The list of strings argument is for error reporting - it usually represents a list of expected tags.

Get the next content element, checking that it has the required tag belonging to the XSD namespace.

Get the next content element, whatever it is.

Grab and parse any and all children of the next element.

interiorWith :: (Content Posn -> Bool) -> XsdParser a -> Element Posn -> XsdParser a Source #

Run an XsdParser on the child contents of the given element (i.e. not in the current monadic content sequence), filtering the children before parsing, and checking that the contents are exhausted, before returning the calculated value within the current parser context.

Check for the presence (and value) of an attribute in the given element. Absence results in failure.

Grab any attributes that declare a locally-used prefix for a specific namespace.

Predicate for whether an attribute belongs to a given namespace.

tidy :: t -> Result x a -> Result t a Source #

Tidy up the parsing context.

Given a URI for a targetNamespace, and a list of Namespaces, tell me the prefix corresponding to the targetNamespace.

lookupBy :: (a -> Bool) -> [a] -> Maybe a Source #

An auxiliary you might expect to find in Data.List

Turn a qualified attribute value (two strings) into a qualified name (QName), but excluding the case where the namespace prefix corresponds to the targetNamespace of the current schema document.

Parse a Schema declaration

Parse a (possibly missing) xsd:annotation element.

Parse a definitely-occurring xsd:annotation element.

Parse a FormDefault attribute.

Parse a Final or Block attribute.

Parse a schema item (just under the toplevel xsd:schema)

Parse an xsd:include.

Parse an xsd:import.

Parse a xsd:redefine.

Parse a xsd:simpleType decl.

Parse a xsd:complexType decl.

Parse the alternative contents of a xsd:complexType decl.

Parse a particle decl.

Parse a particle decl with optional attributes.

Parse an xsd:all, xsd:choice, or xsd:sequence decl.

Parse an xsd:any.

Parse an xsd:element decl.

Parse name and type attributes.

Parse an xsd:attribute decl.

Parse an occurrence range from attributes of given element.

Parse a xsd:unique.

Parse a xsd:key.

Parse a xsd:selector.

Parse a xsd:field.

Text parser for a URI (very simple, non-validating, probably incorrect).

Text parser for an arbitrary string consisting of possibly multiple tokens.

Parse a textual boolean, i.e. "true", "false", "0", or "1"

Parse a "use" attribute value, i.e. "required", "optional", or "prohibited"

Parse a "processContents" attribute, i.e. "skip", "lax", or "strict".

qname :: (String -> String -> QName) -> TextParser QName Source #

Parse an attribute value that should be a QName.

Parse an attribute value that should be a simple Name.