|
|
|
|
|
Description |
A variant of Node in which Element nodes have an annotation of any type,
and some concrete functions that annotate with the XML parse location.
The names conflict with those in Tree so you must use qualified import
if you want to use both modules.
|
|
Synopsis |
|
type Node a tag text = NodeG a [] tag text | | | | type UNode a text = Node a text text | | type LNode tag text = Node XMLParseLocation tag text | | type ULNode text = LNode text text | | module Text.XML.Expat.Internal.NodeClass | | modifyAnnotation :: (a -> a) -> Node a tag text -> Node a tag text | | mapAnnotation :: (a -> b) -> Node a tag text -> Node b tag text | | type QNode a text = Node a (QName text) text | | type QLNode text = LNode (QName text) text | | module Text.XML.Expat.Internal.Qualified | | type NNode a text = Node a (NName text) text | | type NLNode text = LNode (NName text) text | | module Text.XML.Expat.Internal.Namespaced | | data ParseOptions tag text = ParseOptions {} | | defaultParseOptions :: ParseOptions tag text | | | | parse :: (GenericXMLString tag, GenericXMLString text) => ParseOptions tag text -> ByteString -> (LNode tag text, Maybe XMLParseError) | | parse' :: (GenericXMLString tag, GenericXMLString text) => ParseOptions tag text -> ByteString -> Either XMLParseError (LNode tag text) | | data XMLParseError = XMLParseError String XMLParseLocation | | data XMLParseLocation = XMLParseLocation {} | | parseThrowing :: (GenericXMLString tag, GenericXMLString text) => ParseOptions tag text -> ByteString -> LNode tag text | | data XMLParseException = XMLParseException XMLParseError | | | | saxToTree :: GenericXMLString tag => [(SAXEvent tag text, a)] -> (Node a tag text, Maybe XMLParseError) | | class (Monoid s, Eq s) => GenericXMLString s where | | | eAttrs :: Node a tag text -> [(tag, text)] | | parseSAX :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> [SAXEvent tag text] | | parseSAXThrowing :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> [SAXEvent tag text] | | parseSAXLocations :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> [(SAXEvent tag text, XMLParseLocation)] | | parseSAXLocationsThrowing :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> [(SAXEvent tag text, XMLParseLocation)] | | parseTree :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> (LNode tag text, Maybe XMLParseError) | | parseTree' :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> Either XMLParseError (LNode tag text) | | parseTreeThrowing :: (GenericXMLString tag, GenericXMLString text) => Maybe Encoding -> ByteString -> LNode tag text | | unannotate :: Functor c => NodeG a c tag text -> NodeG c tag text | | type ParserOptions tag text = ParseOptions tag text | | defaultParserOptions :: ParseOptions tag text |
|
|
|
Tree structure
|
|
|
A pure tree representation that uses a list as its container type,
annotated variant.
In the hexpat package, a list of nodes has the type [Node tag text], but note
that you can also use the more general type function ListOf to give a list of
any node type, using that node's associated list type, e.g.
ListOf (UNode Text).
|
|
data NodeG a c tag text | Source |
|
Annotated variant of the tree representation of the XML document, meaning
that it has an extra piece of information of your choice attached to each
Element.
c is the container type for the element's children, which is [] in the
hexpat package, and a monadic list type for hexpat-iteratee.
tag is the tag type, which can either be one of several string types,
or a special type from the Text.XML.Expat.Namespaced or
Text.XML.Expat.Qualified modules.
text is the string type for text content.
a is the type of the annotation. One of the things this can be used for
is to store the XML parse location, which is useful for error handling.
Note that some functions in the Text.XML.Expat.Cursor module need to create
new nodes through the MkElementClass type class. Normally this can only be done
if a is a Maybe type (so it can provide the Nothing value for the annotation
on newly created nodes). Or, you can write your own MkElementClass instance.
Apart from that, there is no requirement for a to be a Maybe type.
| Constructors | Element | | eName :: !tag | | eAttributes :: ![(tag, text)] | | eChildren :: c (NodeG a c tag text) | | eAnn :: a | |
| Text !text | |
| Instances | |
|
|
|
Type alias for a single annotated node with unqualified tag names where
tag and text are the same string type
|
|
|
Type alias for a single annotated node, annotated with parse location
|
|
|
Type alias for a single node with unqualified tag names where
tag and text are the same string type, annotated with parse location
|
|
Generic node manipulation
|
|
module Text.XML.Expat.Internal.NodeClass |
|
Annotation-specific
|
|
modifyAnnotation :: (a -> a) -> Node a tag text -> Node a tag text | Source |
|
Modify this node's annotation (non-recursively) if it's an element, otherwise no-op.
|
|
|
Modify this node's annotation and all its children recursively if it's an element, otherwise no-op.
|
|
Qualified nodes
|
|
|
Type alias for a single annotated node where qualified names are used for tags
|
|
|
Type alias for a single node where qualified names are used for tags, annotated with parse location
|
|
module Text.XML.Expat.Internal.Qualified |
|
Namespaced nodes
|
|
|
Type alias for a single annotated node where namespaced names are used for tags
|
|
|
Type alias for a single node where namespaced names are used for tags, annotated with parse location
|
|
module Text.XML.Expat.Internal.Namespaced |
|
Parse to tree
|
|
data ParseOptions tag text | Source |
|
Constructors | ParseOptions | | overrideEncoding :: Maybe Encoding | The encoding parameter, if provided, overrides the document's
encoding declaration.
| entityDecoder :: Maybe (tag -> Maybe text) | If provided, entity references (i.e. and friends) will
be decoded into text using the supplied lookup function
|
|
|
|
|
|
|
|
Encoding types available for the document encoding.
| Constructors | |
|
|
|
:: (GenericXMLString tag, GenericXMLString text) | | => ParseOptions tag text | Optional encoding override
| -> ByteString | Input text (a lazy ByteString)
| -> (LNode tag text, Maybe XMLParseError) | | Lazily parse XML to tree. Note that forcing the XMLParseError return value
will force the entire parse. Therefore, to ensure lazy operation, don't
check the error status until you have processed the tree.
|
|
|
|
|
|
|
Parse error, consisting of message text and error location
| Constructors | | Instances | |
|
|
|
Specifies a location of an event within the input text
| Constructors | XMLParseLocation | | xmlLineNumber :: Int64 | Line number of the event
| xmlColumnNumber :: Int64 | Column number of the event
| xmlByteIndex :: Int64 | Byte index of event from start of document
| xmlByteCount :: Int64 | The number of bytes in the event
|
|
| Instances | |
|
|
Variant that throws exceptions
|
|
|
:: (GenericXMLString tag, GenericXMLString text) | | => ParseOptions tag text | Optional encoding override
| -> ByteString | Input text (a lazy ByteString)
| -> LNode tag text | | Lazily parse XML to tree. In the event of an error, throw XMLParseException.
parseThrowing can throw an exception from pure code, which is generally a bad
way to handle errors, because Haskell's lazy evaluation means it's hard to
predict where it will be thrown from. However, it may be acceptable in
situations where it's not expected during normal operation, depending on the
design of your program.
|
|
|
|
An exception indicating an XML parse error, used by the ..Throwing variants.
| Constructors | | Instances | |
|
|
SAX-style parse
|
|
|
Constructors | StartElement tag [(tag, text)] | | EndElement tag | | CharacterData text | | FailDocument XMLParseError | |
| Instances | |
|
|
|
A lower level function that lazily converts a SAX stream into a tree structure.
Variant that takes annotations for start tags.
|
|
Abstraction of string types
|
|
|
An abstraction for any string type you want to use as xml text (that is,
attribute values or element text content). If you want to use a
new string type with hexpat, you must make it an instance of
GenericXMLString.
| | Methods | | | Instances | |
|
|
Deprecated
|
|
|
|
|
|
|
|
|
|
|
|
|
parseSAXLocationsThrowing | Source |
|
|
|
|
|
|
|
|
|
|
|
|
|
Convert an annotated tree (Annotated module) into a non-annotated
tree (Tree module). DEPRECATED in favour of fromElement.
|
|
|
|
|
DEPRECATED. Renamed to defaultParseOptions.
|
|
Produced by Haddock version 2.6.1 |