-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | A collection of tools for processing XML with Haskell. -- -- The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but -- introduces a more general approach for processing XML with Haskell. -- The Haskell XML Toolbox uses a generic data model for representing XML -- documents, including the DTD subset and the document subset, in -- Haskell. It contains a validating XML parser, a HTML parser, namespace -- support, an XPath expression evaluator, an XSLT library, a RelaxNG -- schema validator and funtions for serialization and deserialization of -- user defined data. The library makes extensive use of the arrow -- approach for processing XML. Since version 9 the toolbox is -- partitioned into various (sub-)packages. This package contains the -- core functionality, hxt-curl, hxt-tagsoup, hxt-relaxng, hxt-xpath, -- hxt-xslt, hxt-regex-xmlschema contain the extensions. hxt-unicode -- contains encoding and decoding functions, hxt-charproperties char -- properties for unicode and XML. @package hxt @version 9.0.0 -- | UTF-8 character parser and simple XML token parsers module Text.XML.HXT.Parser.XmlCharParser -- | parse a single Unicode character xmlChar :: GenParser Char state Unicode -- | parse a XML name character xmlNameChar :: GenParser Char state Unicode -- | parse a XML name start character xmlNameStartChar :: GenParser Char state Unicode -- | parse a XML NCName character xmlNCNameChar :: GenParser Char state Unicode -- | parse a XML NCName start character xmlNCNameStartChar :: GenParser Char state Unicode -- | parse a XML letter character xmlLetter :: GenParser Char state Unicode -- | White Space (2.3) -- -- end of line handling (2.11) #x0D and #x0D#x0A are mapped to #x0A is -- done in XmlInput before parsing otherwise #x0D in internal parsing, -- e.g. for entities would normalize, would be transformed xmlSpaceChar :: GenParser Char state Char -- | A module for regular expression matching based on derivatives of -- regular expressions. -- -- The code was taken from Joe English -- (http://www.flightlab.com/~joe/sgml/validate.html). Tested and -- extended by Martin Schmidt. -- -- Further references for the algorithm: -- -- Janusz A. Brzozowski. -- -- Derivatives of Regular Expressions. Journal of the ACM, Volume 11, -- Issue 4, 1964. -- -- Mark Hopkins. -- -- Regular Expression Package. Posted to comp.compilers, 1994. Available -- per FTP at ftp://iecc.com/pub/file/regex.tar.gz. module Text.XML.HXT.DTDValidation.RE -- | Data type for regular expressions. data RE a RE_ZERO :: String -> RE a RE_UNIT :: RE a RE_SYM :: a -> RE a RE_DOT :: RE a RE_REP :: (RE a) -> RE a RE_PLUS :: (RE a) -> RE a RE_OPT :: (RE a) -> RE a RE_SEQ :: (RE a) -> (RE a) -> RE a RE_ALT :: (RE a) -> (RE a) -> RE a -- | Constructs a regular expression for an empty sequence. -- -- re_unit :: RE a -- | Constructs a regular expression for an empty set. -- -- re_zero :: String -> RE a -- | Constructs a regular expression for accepting a symbol -- -- re_sym :: a -> RE a -- | Constructs an optional repetition (*) of a regular expression -- -- re_rep :: RE a -> RE a -- | Constructs a repetition (+) of a regular expression -- -- re_plus :: RE a -> RE a -- | Constructs an option (?) of a regular expression -- -- re_opt :: RE a -> RE a -- | Constructs a sequence (,) of two regular expressions -- -- re_seq :: RE a -> RE a -> RE a -- | Constructs an alternative (|) of two regular expressions -- -- re_alt :: RE a -> RE a -> RE a -- | Constructs a regular expression for accepting any singel symbol -- -- re_dot :: RE a -- | Checks if an input matched a regular expression. The function should -- be called after matches. -- -- Was the sentence used in matches in the language of the -- regular expression? -> matches e s == s `in` L(e)? -- -- checkRE :: Show a => RE a -> String -- | Derives a regular expression with respect to a sentence. -- -- matches :: (Eq a, Show a) => RE a -> [a] -> RE a -- | Checks if a regular expression matches the empty sequence. -- -- nullable e == [] `in` L(e) -- -- This check indicates if a regular expression fits to a sentence or -- not. -- -- nullable :: Show a => RE a -> Bool -- | Constructs a string representation of a regular expression. -- -- printRE :: Show a => RE a -> String instance Show a => Show (RE a) instance Eq a => Eq (RE a) -- | default mime type table -- -- this file is generated from file etcmime.types module Text.XML.HXT.DOM.MimeTypeDefaults -- | the table with the mapping from file name extensions to mime types mimeTypeDefaults :: [(String, String)] -- | mime type related data and functions module Text.XML.HXT.DOM.MimeTypes type MimeTypeTable = Map String String application_xml :: String application_xml_external_parsed_entity :: String application_xml_dtd :: String text_html :: String text_pdf :: String text_plain :: String text_xml :: String text_xml_external_parsed_entity :: String application_xhtml :: String isTextMimeType :: String -> Bool isHtmlMimeType :: String -> Bool isXmlMimeType :: String -> Bool defaultMimeTypeTable :: MimeTypeTable extensionToMimeType :: String -> MimeTypeTable -> String readMimeTypeTable :: FilePath -> IO MimeTypeTable parseMimeTypeTable :: String -> [(String, String)] -- | Little useful things for strings, lists and other values module Text.XML.HXT.DOM.Util -- | remove leading and trailing whitespace with standard Haskell predicate -- isSpace stringTrim :: String -> String -- | convert string to lowercase with standard Haskell toLower function stringToLower :: String -> String -- | convert string to uppercase with standard Haskell toUpper function stringToUpper :: String -> String -- | find all positions where a string occurs within another string stringAll :: Eq a => [a] -> [a] -> [Int] -- | find the position of the first occurence of a string stringFirst :: Eq a => [a] -> [a] -> Maybe Int -- | find the position of the last occurence of a string stringLast :: Eq a => [a] -> [a] -> Maybe Int -- | Removes leading / trailing whitespaces and leading zeros normalizeNumber :: String -> String -- | Reduce whitespace sequences to a single whitespace normalizeWhitespace :: String -> String -- | replace all whitespace chars by blanks normalizeBlanks :: String -> String -- | Escape all disallowed characters in URI references (see -- http://www.w3.org/TR/xlink/#link-locators) escapeURI :: String -> String -- | escape XML chars < and ampercent by transforming them into -- character references, used for escaping text nodes -- -- see also : attrEscapeXml textEscapeXml :: String -> String -- | escape XML chars <, >, ", and ampercent by -- transforming them into character references -- -- see also : attrEscapeXml stringEscapeXml :: String -> String -- | escape XML chars in attribute values, same as stringEscapeXml, but -- none blank whitespace is also escaped -- -- see also : stringEscapeXml attrEscapeXml :: String -> String stringToInt :: Int -> String -> Int -- | convert a string into a hexadecimal string applying charToHexString -- -- see also : charToHexString stringToHexString :: String -> String -- | convert a char (byte) into a 2-digit hexadecimal string -- -- see also : stringToHexString, intToHexString charToHexString :: Char -> String -- | convert a none negative Int into a hexadecimal string -- -- see also : charToHexString intToHexString :: Int -> String -- | convert a string of hexadecimal digits into an Int hexStringToInt :: String -> Int -- | convert a string of digits into an Int decimalStringToInt :: String -> Int -- | take all elements of a list which occur more than once. The result -- does not contain doubles. (doubles . doubles == doubles) doubles :: Eq a => [a] -> [a] -- | drop all elements from a list which occur more than once. singles :: Eq a => [a] -> [a] -- | remove duplicates from list noDoubles :: Eq a => [a] -> [a] swap :: (a, b) -> (b, a) partitionEither :: [Either a b] -> ([a], [b]) toMaybe :: Bool -> a -> Maybe a -- | mothers little helpers for to much curry uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e -- | Constants for XML keywords, for special attribute names and special -- attribute values module Text.XML.HXT.DOM.XmlKeywords t_root :: String t_xml :: String a_contentLength :: String a_column :: String a_encoding :: String a_kind :: String a_line :: String a_module :: String a_modifier :: String a_name :: String a_output_encoding :: String a_peref :: String a_source :: String a_status :: String a_standalone :: String a_type :: String a_url :: String a_value :: String a_version :: String a_xml :: String a_xmlns :: String a_default :: String v_1 :: String v_2 :: String v_yes :: String v_no :: String v_any :: String v_children :: String v_choice :: String v_empty :: String v_mixed :: String v_seq :: String v_null :: String v_option :: String v_pcdata :: String v_star :: String v_plus :: String v_0 :: String k_cdata :: String k_empty :: String k_entity :: String k_entities :: String k_id :: String k_idref :: String k_idrefs :: String k_include :: String k_ignore :: String k_nmtoken :: String k_nmtokens :: String k_peref :: String k_public :: String k_system :: String k_enumeration :: String k_fixed :: String k_implied :: String k_ndata :: String k_notation :: String k_pcdata :: String k_required :: String k_default :: String k_any :: String dtdPrefix :: String transferProtocol :: String transferMimeType :: String transferEncoding :: String transferURI :: String transferDefaultURI :: String transferStatus :: String transferMessage :: String transferVersion :: String transferPrefix :: String httpPrefix :: String stringProtocol :: String -- | the predefined namespace uri for xml: -- "http://www.w3.org/XML/1998/namespace" xmlNamespace :: String -- | the predefined namespace uri for xmlns: -- "http://www.w3.org/2000/xmlns/" xmlnsNamespace :: String -- | Relax NG namespace relaxNamespace :: String module Text.XML.HXT.Parser.ProtocolHandlerUtil -- | Try to extract charset spec from Content-Type header e.g. "text/html; -- charset=ISO-8859-1" -- -- Sometimes the server deliver the charset spec in quotes these are -- removed parseContentType :: Parser [(String, String)] module Text.XML.HXT.Version hxt_version :: String -- | Version : $Id$ -- -- Datatype library for the W3C XML schema datatypes module Text.XML.HXT.XMLSchema.DataTypeLibW3CNames -- | Namespace of the W3C XML schema datatype library w3cNS :: String xsd_normalizedString :: String xsd_token :: String xsd_language :: String xsd_NMTOKEN :: String xsd_NMTOKENS :: String xsd_Name :: String xsd_NCName :: String xsd_ID :: String xsd_IDREF :: String xsd_IDREFS :: String xsd_ENTITY :: String xsd_ENTITIES :: String xsd_anyURI :: String xsd_QName :: String xsd_NOTATION :: String xsd_hexBinary :: String xsd_base64Binary :: String xsd_decimal :: String xsd_integer :: String xsd_nonPositiveInteger :: String xsd_negativeInteger :: String xsd_nonNegativeInteger :: String xsd_positiveInteger :: String xsd_long :: String xsd_int :: String xsd_short :: String xsd_byte :: String xsd_unsignedLong :: String xsd_unsignedInt :: String xsd_unsignedShort :: String xsd_unsignedByte :: String xsd_string :: String xsd_maxLength :: String xsd_minLength :: String xsd_maxExclusive :: String xsd_minExclusive :: String xsd_maxInclusive :: String xsd_minInclusive :: String xsd_totalDigits :: String xsd_fractionDigits :: String xsd_pattern :: String xsd_enumeration :: String xsd_length :: String -- | Predefined XML Entity References -- -- This module defines a table of all predefined XML entity references module Text.XML.HXT.Parser.XmlEntities -- | list of predefined XML entity names and their unicode values xmlEntities :: [(String, Int)] -- | XHTML Entity References -- -- This module defines a table of all predefined XHTML entity references -- for special or none ASCII chars including the predefined XML entity -- refs module Text.XML.HXT.Parser.XhtmlEntities -- | table with all XHTML entity refs and corresponding unicode values xhtmlEntities :: [(String, Int)] -- | The GET method for file protocol module Text.XML.HXT.IO.GetFILE getStdinCont :: Bool -> IO (Either ([(String, String)], String) String) getCont :: Bool -> String -> IO (Either ([(String, String)], String) String) module Data.Function.Selector -- | A Selector is a pair of an access function and a modifying function -- for reading and updating parts of a composite type data Selector s a S :: (s -> a) -> (a -> s -> s) -> Selector s a getS :: Selector s a -> s -> a setS :: Selector s a -> a -> s -> s chgS :: Selector s a -> (a -> a) -> (s -> s) chgM :: Monad m => Selector s a -> (a -> m a) -> (s -> m s) -- | Alias for constructor S mkSelector :: (s -> a) -> (a -> s -> s) -> Selector s a idS :: Selector s s (.&&&.) :: Selector s a -> Selector s b -> Selector s (a, b) -- | Selectors for pairs and 3-tuples: comp1, comp2, comp3, this can be -- extended to n-tuples class Comp1 s a | s -> a comp1 :: Comp1 s a => Selector s a class Comp2 s a | s -> a comp2 :: Comp2 s a => Selector s a class Comp3 s a | s -> a comp3 :: Comp3 s a => Selector s a instance Comp3 (a, b, c) c instance Comp2 (a, b, c) b instance Comp1 (a, b, c) a instance Comp2 (a, b) b instance Comp1 (a, b) a instance Category Selector -- | Unique Atoms generated from Strings and managed as flyweights -- -- Data.Atom can be used for caching and storage optimisation of -- frequently used strings. An Atom is constructed from a -- String. For two equal strings the identical atom is returned. -- -- This module can be used for optimizing memory usage when working with -- strings or names. Many applications use data types like Map String -- SomeAttribute where a rather fixed set of keys is used. -- Especially XML applications often work with a limited set of element -- and attribute names. For these applications it becomes more memory -- efficient when working with types like Map Atom SomeAttribute -- and convert the keys into atoms before operating on such a map. -- -- Internally this module manages a map of atoms. The atoms are -- internally represented by ByteStrings. When creating a new -- atom from a string, the string is first converted into an UTF8 -- Word8 sequence, which is packed into a ByteString. -- This ByteString is looked up in the table of atoms. If it is -- already there, the value in the map is used as atom, else the new -- ByteString is inserted into the map. -- -- Of course the implementation of this name cache uses -- unsavePerformIO and MVars for managing this kind of -- global state. -- -- The following laws hold for atoms -- -- 
--   s  ==       t => newAtom s  ==       newAtom t
--   s `compare` t => newAtom s `compare` newAtom t
--   show . newAtom == id
--
-- -- Equality test for Atoms runs in O(1), it is just a -- pointer comarison. The Ord comparisons have the same runtime -- like the ByteString comparisons. Internally there is an UTF8 -- comparison, but UTF8 encoding preserves the total order. -- -- Warning: The internal cache never shrinks during execution. So using -- it in a undisciplined way can lead to memory leaks. module Data.Atom data Atom -- | creation of an Atom from a String newAtom :: String -> Atom -- | Insert a String into the atom cache and convert the atom back -- into a String. -- -- locically share == id holds, but internally equal strings -- share the same memory. share :: String -> String instance Typeable Atom instance NFData Atom instance Show Atom instance Read Atom instance Ord Atom instance Eq Atom -- | Simple key value assocciation list implemented as unordered list of -- pairs module Data.AssocList type AssocList k v = [(k, v)] -- | lookup with default value lookupDef :: Eq k => v -> k -> AssocList k v -> v -- | lookup with empty list (empty string) as default value lookup1 :: Eq k => k -> AssocList k [e] -> [e] -- | test for existence of a key hasEntry :: Eq k => k -> AssocList k v -> Bool -- | add an entry, remove an existing entry before adding the new one at -- the top of the list, addEntry is strict addEntry :: Eq k => k -> v -> AssocList k v -> AssocList k v -- | add a whole list of entries with addEntry addEntries :: Eq k => AssocList k v -> AssocList k v -> AssocList k v -- | delete an entry, delEntry is strict delEntry :: Eq k => k -> AssocList k v -> AssocList k v -- | delete a list of entries with delEntry delEntries :: Eq k => [k] -> AssocList k v -> AssocList k v -- | The core data types of the HXT DOM. module Text.XML.HXT.DOM.QualifiedName -- | Namespace support for element and attribute names. -- -- A qualified name consists of a name prefix, a local name and a -- namespace uri. All modules, which are not namespace aware, use only -- the localPart component. When dealing with namespaces, the -- document tree must be processed by -- Text.XML.HXT.Arrow.Namespace.propagateNamespaces to split -- names of structure "prefix:localPart" and label the name with the -- apropriate namespace uri data QName -- | XML names are represented by Strings, but these strings do not mix up -- with normal strings. Names are always reduced to normal form, and they -- are stored internally in a name cache for sharing equal names by the -- same data structure type XName = Atom -- | Type for the namespace association list, used when propagating -- namespaces by modifying the QName values in a tree type NsEnv = AssocList XName XName -- | constructs a complete qualified name with namePrefix, -- localPart and namespaceUri. This function can be used to -- build not wellformed prefix:localpart names. The XPath module uses -- wildcard names like xxx:*. These must be build with -- mkQName and not with mkName. mkQName :: String -> String -> String -> QName -- | constructs a simple, namespace unaware name. If the name is in -- prefix:localpart form and the prefix is not empty the name is -- split internally into a prefix and a local part. mkName :: String -> QName -- | constructs a simple, namespace aware name, with prefix:localPart as -- first parameter, namspace uri as second. -- -- see also mkName, mkPrefixLocalPart mkNsName :: String -> String -> QName -- | old name for mkName mkSNsName :: String -> QName -- | constructs a simple name, with prefix and localPart but without a -- namespace uri. -- -- see also mkQName, mkName mkPrefixLocalPart :: String -> String -> QName -- | Equivalent QNames are defined as follows: The URIs are normalized -- before comparison. Comparison is done with equalQNameBy and -- equivUri equivQName :: QName -> QName -> Bool -- | Comparison of normalized namespace URIs using normalizeNsUri equivUri :: String -> String -> Bool -- | Sometimes a weaker equality relation than equalQName is -- appropriate, e.g no case significance in names, ... a name -- normalization function can be applied to the strings before comparing. -- Called by equalQName and equivQName equalQNameBy :: (String -> String -> Bool) -> QName -> QName -> Bool namePrefix :: QName -> String localPart :: QName -> String namespaceUri :: QName -> String newXName :: String -> XName nullXName :: XName isNullXName :: XName -> Bool mkQName' :: XName -> XName -> XName -> QName -- | access name prefix namePrefix' :: QName -> XName -- | access local part localPart' :: QName -> XName -- | access namespace uri namespaceUri' :: QName -> XName -- | set name prefix setNamePrefix' :: XName -> QName -> QName -- | set local part setLocalPart' :: XName -> QName -> QName -- | set name prefix setNamespaceUri' :: XName -> QName -> QName -- | builds the full name "prefix:localPart", if prefix is not null, else -- the local part is the result qualifiedName :: QName -> String -- | builds the "universal" name, that is the namespace uri surrounded with -- "{" and "}" followed by the local part (specialisation of -- buildUniversalName) universalName :: QName -> String -- | builds an "universal" uri, that is the namespace uri followed by the -- local part. This is usefull for RDF applications, where the subject, -- predicate and object often are concatenated from namespace uri and -- local part (specialisation of buildUniversalName) universalUri :: QName -> String -- | builds a string from the namespace uri and the local part. If the -- namespace uri is empty, the local part is returned, else namespace uri -- and local part are combined with the combining function given by the -- first parameter buildUniversalName :: (String -> String -> String) -> QName -> String -- | Normalization of URIs: Normalization is done by conversion into -- lowercase letters. A trailing "/" is ignored normalizeNsUri :: String -> String -- | Compute the name prefix and the namespace uri for a qualified name. -- -- This function does not test whether the name is a wellformed qualified -- name. see Namespaces in XML Rule [6] to [8]. Error checking is done -- with separate functions, see isWellformedQName and -- isWellformedQualifiedName for error checking. setNamespace :: NsEnv -> QName -> QName -- | test for wellformed NCName, rule [4] XML Namespaces isNCName :: String -> Bool -- | test for wellformed QName, rule [6] XML Namespaces predicate is used -- in filter valdateNamespaces. isWellformedQualifiedName :: String -> Bool -- | test for wellformed QName values. A QName is wellformed, if the local -- part is a NCName, the namePrefix, if not empty, is also a NCName. -- predicate is used in filter valdateNamespaces. isWellformedQName :: QName -> Bool -- | test whether an attribute name is a namesapce declaration name. If -- this is not the case True is the result, else the name must be a well -- formed namespace name: All namespace prefixes starting with "xml" are -- reserved for XML related definitions. predicate is used in filter -- valdateNamespaces. isWellformedNSDecl :: QName -> Bool -- | test for a namespace name to be well formed isWellformedNameSpaceName :: QName -> Bool -- | test whether a name is a namespace declaration attribute name isNameSpaceName :: QName -> Bool -- | predicate is used in filter valdateNamespaces. isDeclaredNamespace :: QName -> Bool xmlNamespaceXName :: XName xmlXName :: XName xmlnsNamespaceXName :: XName xmlnsXName :: XName xmlnsQN :: QName toNsEnv :: AssocList String String -> NsEnv instance Typeable Atom instance Typeable QName instance Eq Atom instance Ord Atom instance Ord QName instance Show QName instance Read QName instance NFData Atom instance Show Atom instance Read Atom instance Binary QName instance NFData QName instance Eq QName -- | Interface definition for trees module Data.Tree.Class -- | The interface for trees class Tree t mkTree :: Tree t => a -> [t a] -> t a mkLeaf :: Tree t => a -> t a isLeaf :: Tree t => t a -> Bool isInner :: Tree t => t a -> Bool getNode :: Tree t => t a -> a getChildren :: Tree t => t a -> [t a] changeNode :: Tree t => (a -> a) -> t a -> t a changeChildren :: Tree t => ([t a] -> [t a]) -> t a -> t a setNode :: Tree t => a -> t a -> t a setChildren :: Tree t => [t a] -> t a -> t a foldTree :: Tree t => (a -> [b] -> b) -> t a -> b nodesTree :: Tree t => t a -> [a] depthTree :: Tree t => t a -> Int cardTree :: Tree t => t a -> Int formatTree :: Tree t => (a -> String) -> t a -> String -- | Interface definition for trees -- -- n-ary tree structure (rose trees) module Data.Tree.NTree.TypeDefs -- | n-ary ordered tree (rose trees) -- -- a tree consists of a node and a possible empty list of children. If -- the list of children is empty, the node is a leaf, else it's an inner -- node. -- -- NTree implements Eq, Ord, Show and Read data NTree a NTree :: a -> (NTrees a) -> NTree a -- | shortcut for a sequence of n-ary trees type NTrees a = [NTree a] -- | convert a tree into a pseudo graphical string reprsentation formatNTreeF :: (node -> String) -> (String -> String) -> (String -> String) -> NTree node -> String -> String instance Typeable1 NTree instance Eq a => Eq (NTree a) instance Ord a => Ord (NTree a) instance Show a => Show (NTree a) instance Read a => Read (NTree a) instance Tree NTree instance Functor NTree instance Binary a => Binary (NTree a) instance NFData a => NFData (NTree a) -- | The core data types of the HXT DOM. module Text.XML.HXT.DOM.TypeDefs -- | Node of xml tree representation type XmlTree = NTree XNode -- | List of nodes of xml tree representation type XmlTrees = NTrees XNode -- | Represents elements data XNode -- | ordinary text (leaf) XText :: String -> XNode -- | character reference (leaf) XCharRef :: Int -> XNode -- | entity reference (leaf) XEntityRef :: String -> XNode -- | comment (leaf) XCmt :: String -> XNode -- | CDATA section (leaf) XCdata :: String -> XNode -- | Processing Instr with qualified name (leaf) with list of attributes. -- If tag name is xml, attributs are "version", "encoding", "standalone", -- else attribute list is empty, content is a text child node XPi :: QName -> XmlTrees -> XNode -- | tag with qualified name and list of attributes (inner node or leaf) XTag :: QName -> XmlTrees -> XNode -- | DTD element with assoc list for dtd element features XDTD :: DTDElem -> Attributes -> XNode -- | attribute with qualified name, the attribute value is stored in -- children XAttr :: QName -> XNode -- | error message with level and text XError :: Int -> String -> XNode -- | Represents a DTD element data DTDElem -- | attr: name, system, public, XDTD elems as children DOCTYPE :: DTDElem -- | attr: name, kind -- -- name: element name -- -- kind: "EMPTY" | "ANY" | "#PCDATA" | children | mixed ELEMENT :: DTDElem -- | element content -- -- attr: kind, modifier -- -- modifier: "" | "?" | "*" | "+" -- -- kind: seq | choice CONTENT :: DTDElem -- | attributes: name - name of element -- -- value - name of attribute -- -- type: "CDATA" | "ID" | "IDREF" | "IDREFS" | "ENTITY" | "ENTITIES" | -- -- "NMTOKEN" | "NMTOKENS" |"NOTATION" | "ENUMTYPE" -- -- kind: "IMPLIED" | "DEFAULT" ATTLIST :: DTDElem -- | for entity declarations ENTITY :: DTDElem -- | for parameter entity declarations PENTITY :: DTDElem -- | for notations NOTATION :: DTDElem -- | for INCLUDEs, IGNOREs and peRefs: attr: type -- -- type = INCLUDE, IGNORE or %...; CONDSECT :: DTDElem -- | attr: name -- -- for lists of names in notation types or nmtokens in enumeration types NAME :: DTDElem -- | for Parameter Entity References in DTDs PEREF :: DTDElem -- | Attribute list -- -- used for storing option lists and features of DTD parts type Attributes = AssocList String String -- | no error, everything is ok c_ok :: Int -- | Error level for XError, type warning c_warn :: Int -- | Error level for XError, type error c_err :: Int -- | Error level for XError, type fatal error c_fatal :: Int -- | data type for representing a set of nodes as a tree structure -- -- this structure is e.g. used to repesent the result of an XPath query -- such that the selected nodes can be processed or selected later in -- processing a document tree data XmlNodeSet XNS :: Bool -> [QName] -> ChildNodes -> XmlNodeSet -- | is this node part of the set ? thisNode :: XmlNodeSet -> Bool -- | the set of attribute nodes attrNodes :: XmlNodeSet -> [QName] -- | the set of child nodes, a list of pairs of index and node set childNodes :: XmlNodeSet -> ChildNodes type ChildNodes = [(Int, XmlNodeSet)] instance Typeable XmlNodeSet instance Typeable DTDElem instance Typeable XNode instance Eq XmlNodeSet instance Show XmlNodeSet instance Eq DTDElem instance Ord DTDElem instance Enum DTDElem instance Show DTDElem instance Read DTDElem instance Eq XNode instance Ord XNode instance Show XNode instance Read XNode instance Binary DTDElem instance NFData DTDElem instance Binary XNode instance NFData XNode -- | The interface to the primitive DOM data types and constants and -- utility functions module Text.XML.HXT.DOM.Interface -- | Interface for XmlArrow to basic data types NTree and XmlTree -- -- If this module must be used in code working with arrows, it should be -- imported qualified e.g. as XN, to prevent name clashes. -- -- For code working on the "node and tree level" this module is the -- interface for writing code without using the constructor functions of -- XNode and NTree directly module Text.XML.HXT.DOM.XmlNode class XmlNode a isText :: XmlNode a => a -> Bool isCharRef :: XmlNode a => a -> Bool isEntityRef :: XmlNode a => a -> Bool isCmt :: XmlNode a => a -> Bool isCdata :: XmlNode a => a -> Bool isPi :: XmlNode a => a -> Bool isElem :: XmlNode a => a -> Bool isRoot :: XmlNode a => a -> Bool isDTD :: XmlNode a => a -> Bool isAttr :: XmlNode a => a -> Bool isError :: XmlNode a => a -> Bool mkText :: XmlNode a => String -> a mkCharRef :: XmlNode a => Int -> a mkEntityRef :: XmlNode a => String -> a mkCmt :: XmlNode a => String -> a mkCdata :: XmlNode a => String -> a mkPi :: XmlNode a => QName -> XmlTrees -> a mkError :: XmlNode a => Int -> String -> a getText :: XmlNode a => a -> Maybe String getCharRef :: XmlNode a => a -> Maybe Int getEntityRef :: XmlNode a => a -> Maybe String getCmt :: XmlNode a => a -> Maybe String getCdata :: XmlNode a => a -> Maybe String getPiName :: XmlNode a => a -> Maybe QName getPiContent :: XmlNode a => a -> Maybe XmlTrees getElemName :: XmlNode a => a -> Maybe QName getAttrl :: XmlNode a => a -> Maybe XmlTrees getDTDPart :: XmlNode a => a -> Maybe DTDElem getDTDAttrl :: XmlNode a => a -> Maybe Attributes getAttrName :: XmlNode a => a -> Maybe QName getErrorLevel :: XmlNode a => a -> Maybe Int getErrorMsg :: XmlNode a => a -> Maybe String getName :: XmlNode a => a -> Maybe QName getQualifiedName :: XmlNode a => a -> Maybe String getUniversalName :: XmlNode a => a -> Maybe String getUniversalUri :: XmlNode a => a -> Maybe String getLocalPart :: XmlNode a => a -> Maybe String getNamePrefix :: XmlNode a => a -> Maybe String getNamespaceUri :: XmlNode a => a -> Maybe String changeText :: XmlNode a => (String -> String) -> a -> a changeCmt :: XmlNode a => (String -> String) -> a -> a changeName :: XmlNode a => (QName -> QName) -> a -> a changeElemName :: XmlNode a => (QName -> QName) -> a -> a changeAttrl :: XmlNode a => (XmlTrees -> XmlTrees) -> a -> a changeAttrName :: XmlNode a => (QName -> QName) -> a -> a changePiName :: XmlNode a => (QName -> QName) -> a -> a changeDTDAttrl :: XmlNode a => (Attributes -> Attributes) -> a -> a setText :: XmlNode a => String -> a -> a setCmt :: XmlNode a => String -> a -> a setName :: XmlNode a => QName -> a -> a setElemName :: XmlNode a => QName -> a -> a setElemAttrl :: XmlNode a => XmlTrees -> a -> a setAttrName :: XmlNode a => QName -> a -> a setPiName :: XmlNode a => QName -> a -> a setDTDAttrl :: XmlNode a => Attributes -> a -> a mkElementNode :: QName -> XmlTrees -> XNode mkAttrNode :: QName -> XNode mkDTDNode :: DTDElem -> Attributes -> XNode mkElement :: QName -> XmlTrees -> XmlTrees -> XmlTree mkRoot :: XmlTrees -> XmlTrees -> XmlTree mkAttr :: QName -> XmlTrees -> XmlTree mkDTDElem :: DTDElem -> Attributes -> XmlTrees -> XmlTree addAttr :: XmlTree -> XmlTrees -> XmlTrees mergeAttrl :: XmlTrees -> XmlTrees -> XmlTrees instance XmlNode a => XmlNode (NTree a) instance XmlNode XNode -- | Parsec parser for XML tokens module Text.XML.HXT.Parser.XmlTokenParser allBut :: (GenParser Char state Char -> GenParser Char state String) -> String -> GenParser Char state String allBut1 :: (GenParser Char state Char -> GenParser Char state String) -> (Char -> Bool) -> String -> GenParser Char state String asciiLetter :: GenParser Char state Char attrValue :: GenParser Char state String bar :: GenParser Char state () charRef :: GenParser Char state Int comma :: GenParser Char state () dq :: GenParser Char state Char encName :: GenParser Char state String entityRef :: GenParser Char state String entityValue :: GenParser Char state String eq :: GenParser Char state () gt :: GenParser Char state Char keyword :: String -> GenParser Char state String keywords :: [String] -> GenParser Char state String lpar :: GenParser Char state () lt :: GenParser Char state Char name :: GenParser Char state String names :: GenParser Char state [String] ncName :: GenParser Char state String nmtoken :: GenParser Char state String nmtokens :: GenParser Char state [String] peReference :: GenParser Char state String pubidLiteral :: GenParser Char state String qName :: GenParser Char state (String, String) quoted :: GenParser Char state a -> GenParser Char state a reference :: GenParser Char state String rpar :: GenParser Char state () semi :: GenParser Char state Char separator :: Char -> GenParser Char state () singleChar :: String -> GenParser Char state Char singleChars :: String -> GenParser Char state String skipS :: GenParser Char state () skipS0 :: GenParser Char state () sPace :: GenParser Char state String sPace0 :: GenParser Char state String sq :: GenParser Char state Char systemLiteral :: GenParser Char state String versionNum :: GenParser Char state String concRes :: GenParser Char state [[a]] -> GenParser Char state [a] mkList :: GenParser Char state a -> GenParser Char state [a] nameT :: GenParser Char state XmlTree nmtokenT :: GenParser Char state XmlTree entityValueT :: GenParser Char state XmlTrees entityTokensT :: String -> GenParser Char state XmlTrees entityCharT :: String -> GenParser Char state XmlTree attrValueT :: GenParser Char state XmlTrees attrValueT' :: String -> GenParser Char state XmlTrees referenceT :: GenParser Char state XmlTree charRefT :: GenParser Char state XmlTree entityRefT :: GenParser Char state XmlTree peReferenceT :: GenParser Char state XmlTree singleCharsT :: String -> GenParser Char state XmlTree -- | Parsec parser for tokenizing DTD declarations for ELEMENT, ATTLIST, -- ENTITY and NOTATION module Text.XML.HXT.Parser.XmlDTDTokenParser dtdDeclTokenizer :: GenParser Char state XmlTree dtdDeclStart :: GenParser Char state (DTDElem, Attributes) dtdDeclEnd :: GenParser Char state () dtdToken :: GenParser Char state XmlTree peReference :: GenParser Char state XmlTree attrValue :: GenParser Char state XmlTree dtdChars :: GenParser Char state XmlTree percent :: GenParser Char state XmlTree -- | Version : $Id$ -- -- Datatypes and functions for building a content model for XML picklers. -- A schema is part of every pickler and can be used to derive a -- corrensponding DTD (or Relax NG schema). This schema further enables -- checking the picklers. module Text.XML.HXT.Arrow.Pickle.Schema -- | The datatype for modelling the structure of an data Schema Any :: Schema Seq :: [Schema] -> Schema sc_l :: Schema -> [Schema] Alt :: [Schema] -> Schema sc_l :: Schema -> [Schema] Rep :: Int -> Int -> Schema -> Schema sc_lb :: Schema -> Int sc_ub :: Schema -> Int sc_1 :: Schema -> Schema Element :: Name -> Schema -> Schema sc_n :: Schema -> Name sc_1 :: Schema -> Schema Attribute :: Name -> Schema -> Schema sc_n :: Schema -> Name sc_1 :: Schema -> Schema ElemRef :: Name -> Schema sc_n :: Schema -> Name CharData :: DataTypeDescr -> Schema sc_dt :: Schema -> DataTypeDescr type Name = String type Schemas = [Schema] data DataTypeDescr DTDescr :: String -> String -> Attributes -> DataTypeDescr dtLib :: DataTypeDescr -> String dtName :: DataTypeDescr -> String dtParams :: DataTypeDescr -> Attributes -- | test: is schema a simple XML Schema datatype isScXsd :: (String -> Bool) -> Schema -> Bool -- | test: is type a fixed value attribute type isScFixed :: Schema -> Bool isScEnum :: Schema -> Bool isScElem :: Schema -> Bool isScAttr :: Schema -> Bool isScElemRef :: Schema -> Bool isScCharData :: Schema -> Bool isScSARE :: Schema -> Bool isScList :: Schema -> Bool isScOpt :: Schema -> Bool -- | access an attribute of a descr of an atomic type xsdParam :: String -> Schema -> String scDT :: String -> String -> Attributes -> Schema scDTxsd :: String -> Attributes -> Schema scString :: Schema scString1 :: Schema scFixed :: String -> Schema scEnum :: [String] -> Schema scNmtoken :: Schema scNmtokens :: Schema scEmpty :: Schema scSeq :: Schema -> Schema -> Schema scSeqs :: [Schema] -> Schema scNull :: Schema scAlt :: Schema -> Schema -> Schema scAlts :: [Schema] -> Schema scOption :: Schema -> Schema scList :: Schema -> Schema scList1 :: Schema -> Schema scOpt :: Schema -> Schema scRep :: Int -> Int -> Schema -> Schema scElem :: String -> Schema -> Schema scAttr :: String -> Schema -> Schema instance Show DataTypeDescr instance Eq Schema instance Show Schema instance Eq DataTypeDescr -- | Version : $Id$ -- -- Functions for converting a pickler schema into a DTD module Text.XML.HXT.Arrow.Pickle.DTD data DTDdescr DTDdescr :: Name -> Schemas -> [(Name, Schemas)] -> DTDdescr -- | convert a DTD descr into XmlTrees dtdDescrToXml :: DTDdescr -> XmlTrees checkAttrModell :: Name -> Schemas -> XmlTrees checkAM :: Name -> Schema -> XmlTrees checkAMC :: Name -> Name -> Schema -> XmlTrees checkContentModell :: Name -> Schema -> XmlTrees scContToXml :: Schema -> (Attributes, XmlTrees) scWrap :: Schema -> Schema scCont :: Attributes -> Schema -> XmlTrees scConts :: Attributes -> Schemas -> XmlTrees scAttrToXml :: Schema -> (Attributes, XmlTrees) checkErr :: Bool -> String -> XmlTrees foundErr :: String -> XmlTrees -- | convert a pickler schema into a DTD descr dtdDescr :: Schema -> DTDdescr elementDeclarations :: Schema -> Schemas elementDecs :: Schemas -> Schemas -> Schemas elemNames :: Schemas -> [Name] elemName :: Schema -> Maybe Name elemRefs :: Schemas -> Schemas attrDec :: Schema -> [(Name, Schemas)] remAttrDec :: Schema -> Schema instance Show DTDdescr -- | XML tree conversion to external string representation module Text.XML.HXT.DOM.ShowXml -- | convert the result of a filter into a string -- -- see also : xmlTreesToText for filter version, -- Text.XML.HXT.Parser.XmlParsec.xread for the inverse operation xshow :: XmlTrees -> String showElemType :: String -> XmlTrees -> String -> String -- | Format a xml tree in tree representation module Text.XML.HXT.DOM.FormatXmlTree formatXmlTree :: XmlTree -> String formatXmlContents :: XmlTree -> XmlTrees -- | Xml Parsec parser with pure filter interface module Text.XML.HXT.Parser.XmlParsec charData :: GenParser Char state XmlTrees charData' :: GenParser Char state XmlTree comment :: GenParser Char state XmlTree pI :: GenParser Char state XmlTree cDSect :: GenParser Char state XmlTree document :: GenParser Char state XmlTree document' :: GenParser Char state XmlTrees prolog :: GenParser Char state XmlTrees xMLDecl :: GenParser Char state XmlTrees xMLDecl' :: GenParser Char state XmlTrees versionInfo :: GenParser Char state XmlTrees misc :: GenParser Char state XmlTree doctypedecl :: GenParser Char state XmlTrees markupdecl :: GenParser Char state XmlTrees sDDecl :: GenParser Char state XmlTrees element :: GenParser Char state XmlTree content :: GenParser Char state XmlTrees contentWithTextDecl :: GenParser Char state XmlTrees textDecl :: GenParser Char state XmlTrees encodingDecl :: GenParser Char state XmlTrees -- | the inverse function to xshow, (for XML content). -- -- the string parameter is parsed with the XML content parser. result is -- the list of trees or in case of an error a single element list with -- the error message as node. No entity or character subtitution is done. -- -- see also: parseXmlContent xread :: String -> XmlTrees -- | Parser for attribute values parseXmlAttrValue :: String -> XmlTree -> XmlTrees -- | the filter version of xread parseXmlContent :: XmlTree -> XmlTrees parseXmlDocEncodingSpec :: XmlTree -> XmlTrees parseXmlDocument :: String -> String -> XmlTrees -- | Parser for parts of a DTD parseXmlDTDPart :: String -> XmlTree -> XmlTrees -- | try to parse a xml encoding spec. -- -- parseXmlEncodingSpec :: Parser XmlTree -> XmlTree -> XmlTrees parseXmlEntityEncodingSpec :: XmlTree -> XmlTrees -- | Parser for general entites parseXmlGeneralEntityValue :: String -> XmlTree -> XmlTrees -- | general parser for parsing arbitray parts of a XML document parseXmlPart :: Parser XmlTrees -> String -> String -> XmlTree -> XmlTrees -- | a more general version of parseXmlContent. The parser to be -- used and the context are extra parameter parseXmlText :: Parser XmlTrees -> String -> XmlTree -> XmlTrees -- | Parser for NMTOKENs parseNMToken :: String -> XmlTree -> XmlTrees -- | Parser for XML names parseName :: String -> XmlTree -> XmlTrees removeEncodingSpec :: XmlTree -> XmlTrees -- | This parser tries to interprete everything as HTML no errors are -- emitted during parsing. If something looks weired, warning messages -- are inserted in the document tree. -- -- All filter are pure XmlFilter, errror handling and IO is done in -- Text.XML.HXT.Parser.HtmlParser or other modules module Text.XML.HXT.Parser.HtmlParsec parseHtmlText :: String -> XmlTree -> XmlTrees parseHtmlDocument :: String -> String -> XmlTrees parseHtmlContent :: String -> XmlTrees isEmptyHtmlTag :: String -> Bool isInnerHtmlTagOf :: String -> String -> Bool closesHtmlTag :: String -> String -> Bool emptyHtmlTags :: [String] -- | Parsec parser for DTD declarations for ELEMENT, ATTLIST, ENTITY and -- NOTATION declarations module Text.XML.HXT.Parser.XmlDTDParser -- | parse a tokenized DTD declaration represented by a DTD tree. The -- content is represented by the children containing text and parameter -- entity reference nodes. The parameter entity reference nodes contain -- their value in the children list, consisting of text and possibly -- again parameter entity reference nodes. This structure is build by the -- parameter entity substitution. Output is again a DTD declaration node, -- but this time completely parsed and ready for further DTD processing parseXmlDTDdecl :: XmlTree -> XmlTrees parseXmlDTDdeclPart :: XmlTree -> XmlTrees parseXmlDTDEntityValue :: XmlTree -> XmlTrees elementDecl :: SParser XmlTrees attlistDecl :: SParser XmlTrees entityDecl :: SParser XmlTrees notationDecl :: SParser XmlTrees -- | Arrows for managing an explicit state -- -- State arrows work similar to state monads. A state value is threaded -- through the application of arrows. module Control.Arrow.ArrowState -- | The interface for accessing and changing the state component. -- -- Multi parameter classes and functional dependencies are required. class Arrow a => ArrowState s a | a -> s changeState :: ArrowState s a => (s -> b -> s) -> a b b accessState :: ArrowState s a => (s -> b -> c) -> a b c getState :: ArrowState s a => a b s setState :: ArrowState s a => a s s nextState :: ArrowState s a => (s -> s) -> a b s -- | Arrows for evaluation of normal form results module Control.Arrow.ArrowNF -- | complete evaluation of an arrow result using Control.DeepSeq -- -- this is sometimes useful for preventing space leaks, especially after -- reading and validation of a document, all DTD stuff is not longer in -- use and can be recycled by the GC. strictA :: (Arrow a, NFData b) => a b b class Arrow a => ArrowNF a rnfA :: (ArrowNF a, NFData c) => a b c -> a b c -- | The list arrow class -- -- This module defines the interface for list arrows. -- -- A list arrow is a function, that gives a list of results for a given -- argument. A single element result represents a normal function. An -- empty list oven indicates, the function is undefined for the given -- argument. The empty list may also represent False, none empty lists -- True. A list with more than one element gives all results for a -- nondeterministic function. module Control.Arrow.ArrowList -- | The interface for list arrows -- -- Only mkA, arr2A, isA '(>>.)' don't have -- default implementations class (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => ArrowList a arr2 :: ArrowList a => (b1 -> b2 -> c) -> a (b1, b2) c arr3 :: ArrowList a => (b1 -> b2 -> b3 -> c) -> a (b1, (b2, b3)) c arr4 :: ArrowList a => (b1 -> b2 -> b3 -> b4 -> c) -> a (b1, (b2, (b3, b4))) c arr2A :: ArrowList a => (b -> a c d) -> a (b, c) d arrL :: ArrowList a => (b -> [c]) -> a b c arr2L :: ArrowList a => (b -> c -> [d]) -> a (b, c) d constA :: ArrowList a => c -> a b c constL :: ArrowList a => [c] -> a b c isA :: ArrowList a => (b -> Bool) -> a b b (>>.) :: ArrowList a => a b c -> ([c] -> [d]) -> a b d (>.) :: ArrowList a => a b c -> ([c] -> d) -> a b d listA :: ArrowList a => a b c -> a b [c] unlistA :: ArrowList a => a [b] b this :: ArrowList a => a b b none :: ArrowList a => a b c withDefault :: ArrowList a => a b c -> c -> a b c single :: ArrowList a => a b c -> a b c applyA :: ArrowList a => a b (a b c) -> a b c ($<) :: ArrowList a => (c -> a b d) -> a b c -> a b d ($<<) :: ArrowList a => (c1 -> c2 -> a b d) -> a b (c1, c2) -> a b d ($<<<) :: ArrowList a => (c1 -> c2 -> c3 -> a b d) -> a b (c1, (c2, c3)) -> a b d ($<<<<) :: ArrowList a => (c1 -> c2 -> c3 -> c4 -> a b d) -> a b (c1, (c2, (c3, c4))) -> a b d ($<$) :: ArrowList a => (c -> (a b b)) -> a b c -> a b b mergeA :: ArrowList a => (a (a1, b1) a1 -> a (a1, b1) b1 -> a (a1, b1) c) -> a (a1, b1) c perform :: ArrowList a => a b c -> a b b catA :: ArrowList a => [a b c] -> a b c seqA :: ArrowList a => [a b b] -> a b b -- | Conditionals for List Arrows -- -- This module defines conditional combinators for list arrows. -- -- The empty list as result represents False, none empty lists True. module Control.Arrow.ArrowIf -- | The interface for arrows as conditionals. -- -- Requires list arrows because False is represented as empty list, True -- as none empty lists. -- -- Only ifA and orElse don't have default implementations class ArrowList a => ArrowIf a ifA :: ArrowIf a => a b c -> a b d -> a b d -> a b d ifP :: ArrowIf a => (b -> Bool) -> a b d -> a b d -> a b d neg :: ArrowIf a => a b c -> a b b when :: ArrowIf a => a b b -> a b c -> a b b whenP :: ArrowIf a => a b b -> (b -> Bool) -> a b b whenNot :: ArrowIf a => a b b -> a b c -> a b b whenNotP :: ArrowIf a => a b b -> (b -> Bool) -> a b b guards :: ArrowIf a => a b c -> a b d -> a b d guardsP :: ArrowIf a => (b -> Bool) -> a b d -> a b d filterA :: ArrowIf a => a b c -> a b b containing :: ArrowIf a => a b c -> a c d -> a b c notContaining :: ArrowIf a => a b c -> a c d -> a b c orElse :: ArrowIf a => a b c -> a b c -> a b c choiceA :: ArrowIf a => [IfThen (a b c) (a b d)] -> a b d tagA :: ArrowIf a => a b c -> a b (Either b b) spanA :: ArrowIf a => a b b -> a [b] ([b], [b]) partitionA :: ArrowIf a => a b b -> a [b] ([b], [b]) -- | an auxiliary data type for choiceA data IfThen a b (:->) :: a -> b -> IfThen a b -- | List arrows for tree processing. -- -- Trees that implement the Data.Tree.Class interface, can be -- processed with these arrows. module Control.Arrow.ArrowTree -- | The interface for tree arrows -- -- all functions have default implementations class (ArrowPlus a, ArrowIf a) => ArrowTree a mkLeaf :: (ArrowTree a, Tree t) => b -> a c (t b) mkTree :: (ArrowTree a, Tree t) => b -> [t b] -> a c (t b) getChildren :: (ArrowTree a, Tree t) => a (t b) (t b) getNode :: (ArrowTree a, Tree t) => a (t b) b setChildren :: (ArrowTree a, Tree t) => [t b] -> a (t b) (t b) setNode :: (ArrowTree a, Tree t) => b -> a (t b) (t b) changeChildren :: (ArrowTree a, Tree t) => ([t b] -> [t b]) -> a (t b) (t b) changeNode :: (ArrowTree a, Tree t) => (b -> b) -> a (t b) (t b) processChildren :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) replaceChildren :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) (/>) :: (ArrowTree a, Tree t) => a b (t c) -> a (t c) d -> a b d (//>) :: (ArrowTree a, Tree t) => a b (t c) -> a (t c) d -> a b d ( a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b) deep :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c deepest :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c multi :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c processBottomUp :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) processTopDown :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) processBottomUpWhenNot :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b) processTopDownUntil :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) insertChildrenAt :: (ArrowTree a, Tree t) => Int -> a (t b) (t b) -> a (t b) (t b) insertChildrenAfter :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b) insertTreeTemplate :: (ArrowTree a, Tree t) => a (t b) (t b) -> [IfThen (a (t b) c) (a (t b) (t b))] -> a (t b) (t b) -- | The interface for trees class Tree t -- | Implementation of pure list arrows module Control.Arrow.ListArrow -- | pure list arrow data type newtype LA a b LA :: (a -> [b]) -> LA a b runLA :: LA a b -> a -> [b] -- | conversion of pure list arrows into other possibly more complex list -- arrows fromLA :: ArrowList a => LA b c -> a b c instance ArrowNF LA instance ArrowTree LA instance ArrowIf LA instance ArrowList LA instance ArrowApply LA instance ArrowChoice LA instance ArrowPlus LA instance ArrowZero LA instance Arrow LA instance Category LA -- | Implementation of list arrows with a state module Control.Arrow.StateListArrow -- | list arrow combined with a state newtype SLA s a b SLA :: (s -> a -> (s, [b])) -> SLA s a b runSLA :: SLA s a b -> s -> a -> (s, [b]) -- | conversion of state list arrows into arbitray other list arrows. -- -- allows running a state list arrow within another arrow: -- -- example: -- -- 
--   ... >>> fromSLA 0 (... setState ... getState ... ) >>> ...
--
-- -- runs a state arrow with initial state 0 (e..g. an Int) within another -- arrow sequence fromSLA :: ArrowList a => s -> SLA s b c -> a b c instance NFData s => ArrowNF (SLA s) instance ArrowTree (SLA s) instance ArrowState s (SLA s) instance ArrowIf (SLA s) instance ArrowList (SLA s) instance ArrowApply (SLA s) instance ArrowChoice (SLA s) instance ArrowPlus (SLA s) instance ArrowZero (SLA s) instance Arrow (SLA s) instance Category (SLA s) -- | Lifting of IO actions to arrows module Control.Arrow.ArrowIO -- | the interface for converting an IO action into an arrow class Arrow a => ArrowIO a arrIO :: ArrowIO a => (b -> IO c) -> a b c arrIO0 :: ArrowIO a => IO c -> a b c arrIO2 :: ArrowIO a => (b1 -> b2 -> IO c) -> a (b1, b2) c arrIO3 :: ArrowIO a => (b1 -> b2 -> b3 -> IO c) -> a (b1, (b2, b3)) c arrIO4 :: ArrowIO a => (b1 -> b2 -> b3 -> b4 -> IO c) -> a (b1, (b2, (b3, b4))) c -- | the interface for converting an IO predicate into a list arrow class (Arrow a, ArrowIO a) => ArrowIOIf a isIOA :: ArrowIOIf a => (b -> IO Bool) -> a b b -- | The exception arrow class module Control.Arrow.ArrowExc class (Arrow a, ArrowChoice a, ArrowZero a, ArrowIO a) => ArrowExc a tryA :: ArrowExc a => a b c -> a b (Either SomeException c) catchA :: ArrowExc a => a b c -> a SomeException c -> a b c -- | Implementation of pure list arrows with IO module Control.Arrow.IOListArrow -- | list arrow combined with IO monad newtype IOLA a b IOLA :: (a -> IO [b]) -> IOLA a b runIOLA :: IOLA a b -> a -> IO [b] instance ArrowNF IOLA instance ArrowTree IOLA instance ArrowIOIf IOLA instance ArrowExc IOLA instance ArrowIO IOLA instance ArrowIf IOLA instance ArrowList IOLA instance ArrowApply IOLA instance ArrowChoice IOLA instance ArrowPlus IOLA instance ArrowZero IOLA instance Arrow IOLA instance Category IOLA -- | Implementation of arrows with IO and a state module Control.Arrow.IOStateListArrow -- | list arrow combined with a state and the IO monad newtype IOSLA s a b IOSLA :: (s -> a -> IO (s, [b])) -> IOSLA s a b runIOSLA :: IOSLA s a b -> s -> a -> IO (s, [b]) -- | lift the state of an IOSLA arrow to a state with an additional -- component. -- -- This is uesful, when running predefined IO arrows, e.g. for document -- input, in a context with a more complex state component. liftSt :: IOSLA s1 b c -> IOSLA (s1, s2) b c -- | run an arrow with augmented state in the context of a simple state -- arrow. An initial value for the new state component is needed. -- -- This is useful, when running an arrow with an extra environment -- component, e.g. for namespace handling in XML. runSt :: s2 -> IOSLA (s1, s2) b c -> IOSLA s1 b c instance NFData s => ArrowNF (IOSLA s) instance ArrowTree (IOSLA s) instance ArrowState s (IOSLA s) instance ArrowIOIf (IOSLA s) instance ArrowExc (IOSLA s) instance ArrowIO (IOSLA s) instance ArrowIf (IOSLA s) instance ArrowList (IOSLA s) instance ArrowApply (IOSLA s) instance ArrowChoice (IOSLA s) instance ArrowPlus (IOSLA s) instance ArrowZero (IOSLA s) instance Arrow (IOSLA s) instance Category (IOSLA s) -- | the basic state arrows for XML processing -- -- A state is needed for global processing options, like encoding -- options, document base URI, trace levels and error message handling -- -- The state is separated into a user defined state and a system state. -- The system state contains variables for error message handling, for -- tracing, for the document base for accessing XML documents with -- relative references, e.g. DTDs, and a global key value store. This -- assoc list has strings as keys and lists of XmlTrees as values. It is -- used to store arbitrary XML and text values, e.g. user defined global -- options. -- -- The user defined part of the store is in the default case empty, -- defined as (). It can be extended with an arbitray data type module Text.XML.HXT.Arrow.XmlState.TypeDefs -- | state datatype consists of a system state and a user state the user -- state is not fixed data XIOState us XIOState :: !XIOSysState -> !us -> XIOState us xioSysState :: XIOState us -> !XIOSysState xioUserState :: XIOState us -> !us -- | The arrow type for stateful arrows type IOStateArrow s b c = IOSLA (XIOState s) b c -- | The arrow for stateful arrows with no user defined state type IOSArrow b c = IOStateArrow () b c -- | read the user defined part of the state getUserState :: IOStateArrow s b s -- | change the user defined part of the state changeUserState :: (b -> s -> s) -> IOStateArrow s b b -- | set the user defined part of the state setUserState :: IOStateArrow s s s -- | extend user state -- -- Run an arrow with an extended user state component, The old component -- is stored together with a new one in a pair, the arrow is executed -- with this extended state, and the augmented state component is removed -- form the state when the arrow has finished its execution withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c -- | change the type of user state -- -- This conversion is useful, when running a state arrow with another -- structure of the user state, e.g. with () when executing some IO -- arrows withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c -- | predefined system state data type with all components for the system -- functions, like trace, error handling, ... data XIOSysState XIOSys :: !XIOSysWriter -> !XIOSysEnv -> XIOSysState xioSysWriter :: XIOSysState -> !XIOSysWriter xioSysEnv :: XIOSysState -> !XIOSysEnv data XIOSysWriter XIOwrt :: !XmlTrees -> XIOSysWriter xioErrorMsgList :: XIOSysWriter -> !XmlTrees data XIOSysEnv XIOEnv :: !Int -> (Int -> String -> IO ()) -> !Int -> (String -> IO ()) -> !Bool -> !String -> !String -> !Attributes -> !XIOInputConfig -> !XIOParseConfig -> !XIOOutputConfig -> !XIORelaxConfig -> !XIOCacheConfig -> XIOSysEnv xioTraceLevel :: XIOSysEnv -> !Int xioTraceCmd :: XIOSysEnv -> Int -> String -> IO () xioErrorStatus :: XIOSysEnv -> !Int xioErrorMsgHandler :: XIOSysEnv -> String -> IO () xioErrorMsgCollect :: XIOSysEnv -> !Bool xioBaseURI :: XIOSysEnv -> !String xioDefaultBaseURI :: XIOSysEnv -> !String xioAttrList :: XIOSysEnv -> !Attributes xioInputConfig :: XIOSysEnv -> !XIOInputConfig xioParseConfig :: XIOSysEnv -> !XIOParseConfig xioOutputConfig :: XIOSysEnv -> !XIOOutputConfig xioRelaxConfig :: XIOSysEnv -> !XIORelaxConfig xioCacheConfig :: XIOSysEnv -> !XIOCacheConfig data XIOInputConfig XIOIcgf :: !Bool -> !Bool -> String -> IOSArrow XmlTree XmlTree -> !Attributes -> !Bool -> String -> XIOInputConfig xioStrictInput :: XIOInputConfig -> !Bool xioEncodingErrors :: XIOInputConfig -> !Bool xioInputEncoding :: XIOInputConfig -> String xioHttpHandler :: XIOInputConfig -> IOSArrow XmlTree XmlTree xioInputOptions :: XIOInputConfig -> !Attributes xioRedirect :: XIOInputConfig -> !Bool xioProxy :: XIOInputConfig -> String data XIOParseConfig XIOPcfg :: MimeTypeTable -> String -> [String] -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> IOSArrow XmlTree XmlTree -> XIOParseConfig xioMimeTypes :: XIOParseConfig -> MimeTypeTable xioMimeTypeFile :: XIOParseConfig -> String xioAcceptedMimeTypes :: XIOParseConfig -> [String] xioWarnings :: XIOParseConfig -> !Bool xioRemoveWS :: XIOParseConfig -> !Bool xioParseByMimeType :: XIOParseConfig -> !Bool xioParseHTML :: XIOParseConfig -> !Bool xioLowerCaseNames :: XIOParseConfig -> !Bool xioPreserveComment :: XIOParseConfig -> !Bool xioValidate :: XIOParseConfig -> !Bool xioCheckNamespaces :: XIOParseConfig -> !Bool xioCanonicalize :: XIOParseConfig -> !Bool xioIgnoreNoneXmlContents :: XIOParseConfig -> !Bool xioTagSoup :: XIOParseConfig -> !Bool xioTagSoupParser :: XIOParseConfig -> IOSArrow XmlTree XmlTree data XIOOutputConfig XIOOcfg :: !Bool -> !String -> !XIOXoutConfig -> !Bool -> ![String] -> !Bool -> !Bool -> !Bool -> !Bool -> XIOOutputConfig xioIndent :: XIOOutputConfig -> !Bool xioOutputEncoding :: XIOOutputConfig -> !String xioOutputFmt :: XIOOutputConfig -> !XIOXoutConfig xioXmlPi :: XIOOutputConfig -> !Bool xioNoEmptyElemFor :: XIOOutputConfig -> ![String] xioAddDefaultDTD :: XIOOutputConfig -> !Bool xioTextMode :: XIOOutputConfig -> !Bool xioShowTree :: XIOOutputConfig -> !Bool xioShowHaskell :: XIOOutputConfig -> !Bool data XIOXoutConfig XMLoutput :: XIOXoutConfig XHTMLoutput :: XIOXoutConfig HTMLoutput :: XIOXoutConfig PLAINoutput :: XIOXoutConfig data XIORelaxConfig XIORxc :: !Bool -> String -> !Bool -> !Bool -> !Bool -> !Bool -> !Int -> !Int -> AssocList String XmlTrees -> IOSArrow XmlTree XmlTree -> XIORelaxConfig xioRelaxValidate :: XIORelaxConfig -> !Bool xioRelaxSchema :: XIORelaxConfig -> String xioRelaxCheckRestr :: XIORelaxConfig -> !Bool xioRelaxValidateExtRef :: XIORelaxConfig -> !Bool xioRelaxValidateInclude :: XIORelaxConfig -> !Bool xioRelaxCollectErrors :: XIORelaxConfig -> !Bool xioRelaxNoOfErrors :: XIORelaxConfig -> !Int xioRelaxDefineId :: XIORelaxConfig -> !Int xioRelaxAttrList :: XIORelaxConfig -> AssocList String XmlTrees xioRelaxValidator :: XIORelaxConfig -> IOSArrow XmlTree XmlTree data XIOCacheConfig XIOCch :: CompressionFct -> DeCompressionFct -> !Bool -> !String -> !Int -> !Bool -> (String -> IOSArrow XmlTree XmlTree) -> XIOCacheConfig xioBinaryCompression :: XIOCacheConfig -> CompressionFct xioBinaryDeCompression :: XIOCacheConfig -> DeCompressionFct xioWithCache :: XIOCacheConfig -> !Bool xioCacheDir :: XIOCacheConfig -> !String xioDocumentAge :: XIOCacheConfig -> !Int xioCache404Err :: XIOCacheConfig -> !Bool xioCacheRead :: XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree type CompressionFct = ByteString -> ByteString type DeCompressionFct = ByteString -> ByteString type SysConfig = XIOSysState -> XIOSysState type SysConfigList = [SysConfig] theSysState :: Selector (XIOState us) XIOSysState theUserState :: Selector (XIOState us) us theSysWriter :: Selector XIOSysState XIOSysWriter theErrorMsgList :: Selector XIOSysState XmlTrees theSysEnv :: Selector XIOSysState XIOSysEnv theInputConfig :: Selector XIOSysState XIOInputConfig theStrictInput :: Selector XIOSysState Bool theEncodingErrors :: Selector XIOSysState Bool theInputEncoding :: Selector XIOSysState String theHttpHandler :: Selector XIOSysState (IOSArrow XmlTree XmlTree) theInputOptions :: Selector XIOSysState Attributes theRedirect :: Selector XIOSysState Bool theProxy :: Selector XIOSysState String theOutputConfig :: Selector XIOSysState XIOOutputConfig theIndent :: Selector XIOSysState Bool theOutputEncoding :: Selector XIOSysState String theOutputFmt :: Selector XIOSysState XIOXoutConfig theXmlPi :: Selector XIOSysState Bool theNoEmptyElemFor :: Selector XIOSysState [String] theAddDefaultDTD :: Selector XIOSysState Bool theTextMode :: Selector XIOSysState Bool theShowTree :: Selector XIOSysState Bool theShowHaskell :: Selector XIOSysState Bool theRelaxConfig :: Selector XIOSysState XIORelaxConfig theRelaxValidate :: Selector XIOSysState Bool theRelaxSchema :: Selector XIOSysState String theRelaxCheckRestr :: Selector XIOSysState Bool theRelaxValidateExtRef :: Selector XIOSysState Bool theRelaxValidateInclude :: Selector XIOSysState Bool theRelaxCollectErrors :: Selector XIOSysState Bool theRelaxNoOfErrors :: Selector XIOSysState Int theRelaxDefineId :: Selector XIOSysState Int theRelaxAttrList :: Selector XIOSysState (AssocList String XmlTrees) theRelaxValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree) theParseConfig :: Selector XIOSysState XIOParseConfig theErrorStatus :: Selector XIOSysState Int theErrorMsgHandler :: Selector XIOSysState (String -> IO ()) theErrorMsgCollect :: Selector XIOSysState Bool theBaseURI :: Selector XIOSysState String theDefaultBaseURI :: Selector XIOSysState String theTraceLevel :: Selector XIOSysState Int theTraceCmd :: Selector XIOSysState (Int -> String -> IO ()) theTrace :: Selector XIOSysState (Int, Int -> String -> IO ()) theAttrList :: Selector XIOSysState Attributes theMimeTypes :: Selector XIOSysState MimeTypeTable theMimeTypeFile :: Selector XIOSysState String theAcceptedMimeTypes :: Selector XIOSysState [String] theWarnings :: Selector XIOSysState Bool theRemoveWS :: Selector XIOSysState Bool thePreserveComment :: Selector XIOSysState Bool theParseByMimeType :: Selector XIOSysState Bool theParseHTML :: Selector XIOSysState Bool theLowerCaseNames :: Selector XIOSysState Bool theValidate :: Selector XIOSysState Bool theCheckNamespaces :: Selector XIOSysState Bool theCanonicalize :: Selector XIOSysState Bool theIgnoreNoneXmlContents :: Selector XIOSysState Bool theTagSoup :: Selector XIOSysState Bool theTagSoupParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree) theCacheConfig :: Selector XIOSysState XIOCacheConfig theBinaryCompression :: Selector XIOSysState (ByteString -> ByteString) theBinaryDeCompression :: Selector XIOSysState (ByteString -> ByteString) theWithCache :: Selector XIOSysState Bool theCacheDir :: Selector XIOSysState String theDocumentAge :: Selector XIOSysState Int theCache404Err :: Selector XIOSysState Bool theCacheRead :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree) getSysVar :: Selector XIOSysState c -> IOStateArrow s b c setSysVar :: Selector XIOSysState c -> IOStateArrow s c c chgSysVar :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b configSysVar :: SysConfig -> IOStateArrow s c c configSysVars :: SysConfigList -> IOStateArrow s c c localSysVar :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b localSysEnv :: IOStateArrow s a b -> IOStateArrow s a b incrSysVar :: Selector XIOSysState Int -> IOStateArrow s a Int -- | store a string in global state under a given attribute name setSysAttr :: String -> IOStateArrow s String String -- | remove an entry in global state, arrow input remains unchanged unsetSysAttr :: String -> IOStateArrow s b b -- | read an attribute value from global state getSysAttr :: String -> IOStateArrow s b String -- | read all attributes from global state getAllSysAttrs :: IOStateArrow s b Attributes setSysAttrString :: String -> String -> IOStateArrow s b b -- | store an int value in global state setSysAttrInt :: String -> Int -> IOStateArrow s b b -- | read an int value from global state -- -- 
--   getSysAttrInt 0 myIntAttr
--
getSysAttrInt :: Int -> String -> IOStateArrow s b Int toInt :: Int -> String -> Int -- | A Selector is a pair of an access function and a modifying function -- for reading and updating parts of a composite type data Selector s a S :: (s -> a) -> (a -> s -> s) -> Selector s a getS :: Selector s a -> s -> a setS :: Selector s a -> a -> s -> s chgS :: Selector s a -> (a -> a) -> (s -> s) idS :: Selector s s (.&&&.) :: Selector s a -> Selector s b -> Selector s (a, b) instance Eq XIOXoutConfig instance NFData XIOSysState instance NFData us => NFData (XIOState us) -- | the mime type configuration functions module Text.XML.HXT.Arrow.XmlState.MimeTypeTable -- | set the table mapping of file extensions to mime types in the system -- state -- -- Default table is defined in -- Text.XML.HXT.DOM.MimeTypeDefaults. This table is used when -- reading loacl files, (file: protocol) to determine the mime type setMimeTypeTable :: MimeTypeTable -> IOStateArrow s b b -- | set the table mapping of file extensions to mime types by an external -- config file -- -- The config file must follow the conventions of etcmime.types on -- a debian linux system, that means all empty lines and all lines -- starting with a # are ignored. The other lines must consist of a mime -- type followed by a possible empty list of extensions. The list of -- extenstions and mime types overwrites the default list in the system -- state of the IOStateArrow setMimeTypeTableFromFile :: FilePath -> IOStateArrow s b b -- | read the system mimetype table getMimeTypeTable :: IOStateArrow s b MimeTypeTable -- | Basic arrows for processing XML documents -- -- All arrows use IO and a global state for options, errorhandling, ... module Text.XML.HXT.Arrow.XmlArrow -- | Arrows for processing Text.XML.HXT.DOM.TypeDefs.XmlTrees -- -- These arrows can be grouped into predicates, selectors, constructors, -- and transformers. -- -- All predicates (tests) act like Control.Arrow.ArrowIf.none -- for failure and Control.Arrow.ArrowIf.this for success. A -- logical and can be formed by a1 >>> a2 , a locical -- or by a1 <+> a2 . -- -- Selector arrows will fail, when applied to wrong input, e.g. selecting -- the text of a node with getText will fail when applied to a -- none text node. -- -- Edit arrows will remain the input unchanged, when applied to wrong -- argument, e.g. editing the content of a text node with -- changeText applied to an element node will return the unchanged -- element node. class (Arrow a, ArrowList a, ArrowTree a) => ArrowXml a isText :: ArrowXml a => a XmlTree XmlTree isCharRef :: ArrowXml a => a XmlTree XmlTree isEntityRef :: ArrowXml a => a XmlTree XmlTree isCmt :: ArrowXml a => a XmlTree XmlTree isCdata :: ArrowXml a => a XmlTree XmlTree isPi :: ArrowXml a => a XmlTree XmlTree isXmlPi :: ArrowXml a => a XmlTree XmlTree isElem :: ArrowXml a => a XmlTree XmlTree isDTD :: ArrowXml a => a XmlTree XmlTree isAttr :: ArrowXml a => a XmlTree XmlTree isError :: ArrowXml a => a XmlTree XmlTree isRoot :: ArrowXml a => a XmlTree XmlTree hasText :: ArrowXml a => (String -> Bool) -> a XmlTree XmlTree isWhiteSpace :: ArrowXml a => a XmlTree XmlTree hasNameWith :: ArrowXml a => (QName -> Bool) -> a XmlTree XmlTree hasQName :: ArrowXml a => QName -> a XmlTree XmlTree hasName :: ArrowXml a => String -> a XmlTree XmlTree hasLocalPart :: ArrowXml a => String -> a XmlTree XmlTree hasNamePrefix :: ArrowXml a => String -> a XmlTree XmlTree hasNamespaceUri :: ArrowXml a => String -> a XmlTree XmlTree hasAttr :: ArrowXml a => String -> a XmlTree XmlTree hasQAttr :: ArrowXml a => QName -> a XmlTree XmlTree hasAttrValue :: ArrowXml a => String -> (String -> Bool) -> a XmlTree XmlTree hasQAttrValue :: ArrowXml a => QName -> (String -> Bool) -> a XmlTree XmlTree mkText :: ArrowXml a => a String XmlTree mkCharRef :: ArrowXml a => a Int XmlTree mkEntityRef :: ArrowXml a => a String XmlTree mkCmt :: ArrowXml a => a String XmlTree mkCdata :: ArrowXml a => a String XmlTree mkError :: ArrowXml a => Int -> a String XmlTree mkElement :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree -> a n XmlTree mkAttr :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree mkPi :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree mkqelem :: ArrowXml a => QName -> [a n XmlTree] -> [a n XmlTree] -> a n XmlTree mkelem :: ArrowXml a => String -> [a n XmlTree] -> [a n XmlTree] -> a n XmlTree aelem :: ArrowXml a => String -> [a n XmlTree] -> a n XmlTree selem :: ArrowXml a => String -> [a n XmlTree] -> a n XmlTree eelem :: ArrowXml a => String -> a n XmlTree root :: ArrowXml a => [a n XmlTree] -> [a n XmlTree] -> a n XmlTree qattr :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree attr :: ArrowXml a => String -> a n XmlTree -> a n XmlTree txt :: ArrowXml a => String -> a n XmlTree charRef :: ArrowXml a => Int -> a n XmlTree entityRef :: ArrowXml a => String -> a n XmlTree cmt :: ArrowXml a => String -> a n XmlTree warn :: ArrowXml a => String -> a n XmlTree err :: ArrowXml a => String -> a n XmlTree fatal :: ArrowXml a => String -> a n XmlTree spi :: ArrowXml a => String -> String -> a n XmlTree sqattr :: ArrowXml a => QName -> String -> a n XmlTree sattr :: ArrowXml a => String -> String -> a n XmlTree getText :: ArrowXml a => a XmlTree String getCharRef :: ArrowXml a => a XmlTree Int getEntityRef :: ArrowXml a => a XmlTree String getCmt :: ArrowXml a => a XmlTree String getCdata :: ArrowXml a => a XmlTree String getPiName :: ArrowXml a => a XmlTree QName getPiContent :: ArrowXml a => a XmlTree XmlTree getElemName :: ArrowXml a => a XmlTree QName getAttrl :: ArrowXml a => a XmlTree XmlTree getDTDPart :: ArrowXml a => a XmlTree DTDElem getDTDAttrl :: ArrowXml a => a XmlTree Attributes getAttrName :: ArrowXml a => a XmlTree QName getErrorLevel :: ArrowXml a => a XmlTree Int getErrorMsg :: ArrowXml a => a XmlTree String getQName :: ArrowXml a => a XmlTree QName getName :: ArrowXml a => a XmlTree String getUniversalName :: ArrowXml a => a XmlTree String getUniversalUri :: ArrowXml a => a XmlTree String getLocalPart :: ArrowXml a => a XmlTree String getNamePrefix :: ArrowXml a => a XmlTree String getNamespaceUri :: ArrowXml a => a XmlTree String getAttrValue :: ArrowXml a => String -> a XmlTree String getAttrValue0 :: ArrowXml a => String -> a XmlTree String getQAttrValue :: ArrowXml a => QName -> a XmlTree String getQAttrValue0 :: ArrowXml a => QName -> a XmlTree String changeText :: ArrowXml a => (String -> String) -> a XmlTree XmlTree changeCmt :: ArrowXml a => (String -> String) -> a XmlTree XmlTree changeQName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree changeElemName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree changeAttrName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree changePiName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree changeAttrValue :: ArrowXml a => (String -> String) -> a XmlTree XmlTree changeAttrl :: ArrowXml a => (XmlTrees -> XmlTrees -> XmlTrees) -> a XmlTree XmlTree -> a XmlTree XmlTree setQName :: ArrowXml a => QName -> a XmlTree XmlTree setElemName :: ArrowXml a => QName -> a XmlTree XmlTree setAttrName :: ArrowXml a => QName -> a XmlTree XmlTree setPiName :: ArrowXml a => QName -> a XmlTree XmlTree setAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree addAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree addAttr :: ArrowXml a => String -> String -> a XmlTree XmlTree removeAttr :: ArrowXml a => String -> a XmlTree XmlTree removeQAttr :: ArrowXml a => QName -> a XmlTree XmlTree processAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree processTopDownWithAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree (+=) :: ArrowXml a => a b XmlTree -> a b XmlTree -> a b XmlTree xshow :: ArrowXml a => a n XmlTree -> a n String -- | Document Type Definition arrows -- -- These are separated, because they are not needed for document -- processing, only when processing the DTD, e.g. for generating access -- funtions for the toolbox from a DTD (se example DTDtoHaskell in the -- examples directory) class ArrowXml a => ArrowDTD a isDTDDoctype :: ArrowDTD a => a XmlTree XmlTree isDTDElement :: ArrowDTD a => a XmlTree XmlTree isDTDContent :: ArrowDTD a => a XmlTree XmlTree isDTDAttlist :: ArrowDTD a => a XmlTree XmlTree isDTDEntity :: ArrowDTD a => a XmlTree XmlTree isDTDPEntity :: ArrowDTD a => a XmlTree XmlTree isDTDNotation :: ArrowDTD a => a XmlTree XmlTree isDTDCondSect :: ArrowDTD a => a XmlTree XmlTree isDTDName :: ArrowDTD a => a XmlTree XmlTree isDTDPERef :: ArrowDTD a => a XmlTree XmlTree hasDTDAttr :: ArrowDTD a => String -> a XmlTree XmlTree getDTDAttrValue :: ArrowDTD a => String -> a XmlTree String setDTDAttrValue :: ArrowDTD a => String -> String -> a XmlTree XmlTree mkDTDElem :: ArrowDTD a => DTDElem -> Attributes -> a n XmlTree -> a n XmlTree mkDTDDoctype :: ArrowDTD a => Attributes -> a n XmlTree -> a n XmlTree mkDTDElement :: ArrowDTD a => Attributes -> a n XmlTree mkDTDEntity :: ArrowDTD a => Attributes -> a n XmlTree mkDTDPEntity :: ArrowDTD a => Attributes -> a n XmlTree instance ArrowDTD (IOSLA s) instance ArrowDTD IOLA instance ArrowDTD (SLA s) instance ArrowDTD LA instance ArrowXml (IOSLA s) instance ArrowXml IOLA instance ArrowXml (SLA s) instance ArrowXml LA -- | the basic state arrows for XML processing -- -- A state is needed for global processing options, like encoding -- options, document base URI, trace levels and error message handling -- -- The state is separated into a user defined state and a system state. -- The system state contains variables for error message handling, for -- tracing, for the document base for accessing XML documents with -- relative references, e.g. DTDs, and a global key value store. This -- assoc list has strings as keys and lists of XmlTrees as values. It is -- used to store arbitrary XML and text values, e.g. user defined global -- options. -- -- The user defined part of the store is in the default case empty, -- defined as (). It can be extended with an arbitray data type module Text.XML.HXT.Arrow.XmlState.ErrorHandling changeErrorStatus :: (Int -> Int -> Int) -> IOStateArrow s Int Int -- | reset global error variable clearErrStatus :: IOStateArrow s b b -- | set global error variable setErrStatus :: IOStateArrow s Int Int -- | read current global error status getErrStatus :: IOStateArrow s XmlTree Int -- | raise the global error status level to that of the input tree setErrMsgStatus :: IOStateArrow s XmlTree XmlTree -- | set the error message handler and the flag for collecting the errors setErrorMsgHandler :: Bool -> (String -> IO ()) -> IOStateArrow s b b -- | error message handler for output to stderr sysErrorMsg :: IOStateArrow s XmlTree XmlTree -- | the default error message handler: error output to stderr errorMsgStderr :: IOStateArrow s b b -- | error message handler for collecting errors errorMsgCollect :: IOStateArrow s b b -- | error message handler for output to stderr and collecting errorMsgStderrAndCollect :: IOStateArrow s b b -- | error message handler for ignoring errors errorMsgIgnore :: IOStateArrow s b b -- | if error messages are collected by the error handler for processing -- these messages by the calling application, this arrow reads the stored -- messages and clears the error message store getErrorMessages :: IOStateArrow s b XmlTree addToErrorMsgList :: IOStateArrow s XmlTree XmlTree -- | filter error messages from input trees and issue errors filterErrorMsg :: IOStateArrow s XmlTree XmlTree -- | generate a warnig message issueWarn :: String -> IOStateArrow s b b -- | generate an error message issueErr :: String -> IOStateArrow s b b -- | generate a fatal error message, e.g. document not found issueFatal :: String -> IOStateArrow s b b -- | Default exception handler: issue a fatal error message and fail. -- -- The parameter can be used to specify where the error occured issueExc :: String -> IOStateArrow s SomeException b -- | add the error level and the module where the error occured to the -- attributes of a document root node and remove the children when level -- is greater or equal to c_err. called by -- setDocumentStatusFromSystemState when the system state -- indicates an error setDocumentStatus :: Int -> String -> IOStateArrow s XmlTree XmlTree -- | check whether the error level attribute in the system state is set to -- error, in this case the children of the document root are removed and -- the module name where the error occured and the error level are added -- as attributes with setDocumentStatus else nothing is changed setDocumentStatusFromSystemState :: String -> IOStateArrow s XmlTree XmlTree -- | check whether tree is a document root and the status attribute has a -- value less than c_err documentStatusOk :: ArrowXml a => a XmlTree XmlTree errorOutputToStderr :: String -> IO () -- | system configuration and common options options module Text.XML.HXT.Arrow.XmlState.SystemConfig -- | withTace level : system option, set the trace level, (0..4) withTrace :: Int -> SysConfig -- | withSysAttr key value : store an arbitarty key value pair in -- system state withSysAttr :: String -> String -> SysConfig withAcceptedMimeTypes :: [String] -> SysConfig -- | withMimeTypeFile filename : input option, set the mime type -- table for file: documents by given file. The format of this -- config file must be in the syntax of a debian linux "mime.types" -- config file withMimeTypeFile :: String -> SysConfig -- | withWarnings yes/no : system option, issue warnings during -- reading, HTML parsing and processing, default is yes withWarnings :: Bool -> SysConfig -- | withErrors yes/no : system option for suppressing error -- messages, default is no withErrors :: Bool -> SysConfig -- | withRemoveWS yes/no : read and write option, remove all -- whitespace, used for document indentation, default is no withRemoveWS :: Bool -> SysConfig -- | withPreserveComment yes/no : read option, preserve comments -- during canonicalization, default is no withPreserveComment :: Bool -> SysConfig -- | withParseByMimeType yes/no : read option, select the parser -- by the mime type of the document (pulled out of the HTTP header). -- -- When the mime type is set to "text/html" the configured HTML parser is -- taken, when it's set to "text/xml" or "text/xhtml" the configured XML -- parser is taken. If the mime type is something else, no further -- processing is performed, the contents is given back to the application -- in form of a single text node. If the default document encoding is set -- to isoLatin1, this even enables processing of arbitray binary data. withParseByMimeType :: Bool -> SysConfig -- | withParseHTML yes/no: read option, use HTML parser, default -- is no (use XML parser) withParseHTML :: Bool -> SysConfig -- | withValidate yes/no: read option, validate document againsd -- DTD, default is yes withValidate :: Bool -> SysConfig -- | withCheckNamespaces yes/no: read option, check namespaces, -- default is no withCheckNamespaces :: Bool -> SysConfig -- | withCanonicalize yes/no : read option, canonicalize document, -- default is yes withCanonicalize :: Bool -> SysConfig -- | withIgnoreNoneXmlContents yes/no : input option, ignore -- document contents of none XML/HTML documents. -- -- This option can be useful for implementing crawler like applications, -- e.g. an URL checker. In those cases net traffic can be reduced. withIgnoreNoneXmlContents :: Bool -> SysConfig -- | withStrictInput yes/no : input option, input of file and HTTP -- contents is read eagerly, default is no withStrictInput :: Bool -> SysConfig -- | withEncodingErrors yes/no : input option, ignore all encoding -- errors, default is no withEncodingErrors :: Bool -> SysConfig -- | withInputEncoding encodingName : input option -- -- Set default document encoding (utf8, isoLatin1, -- usAscii, iso8859_2, ... , iso8859_16, ...). Only -- XML, HTML and text documents are decoded, default decoding for -- XML/HTML is utf8, for text iso latin1 (no decoding). withInputEncoding :: String -> SysConfig -- | withDefaultBaseURI URI , input option, set the default base -- URI -- -- This option can be useful when parsing documents from stdin or -- contained in a string, and interpreting relative URIs within the -- document withDefaultBaseURI :: String -> SysConfig withInputOption :: String -> String -> SysConfig withInputOptions :: Attributes -> SysConfig -- | withRedirect yes/no : input option, automatically follow -- redirected URIs, default is yes withRedirect :: Bool -> SysConfig -- | withProxy "host:port" : input option, configure a proxy for -- HTTP access, e.g. www-cache:3128 withProxy :: String -> SysConfig -- | withIndent yes/no : output option, indent document before -- output, default is no withIndent :: Bool -> SysConfig -- | withOutputEncoding encoding , output option, default is the -- default input encoding or utf8, if input encoding is not set withOutputEncoding :: String -> SysConfig -- | withOutputXML : output option, default writing -- -- Default is writing XML: quote special XML chars >,<,",',& -- where neccessary, add XML processing instruction and encode document -- with respect to withOutputEncoding withOutputXML :: SysConfig -- | Write XHTML: quote all special XML chars, use HTML entity refs or char -- refs for none ASCII chars withOutputHTML :: SysConfig -- | Write XML: quote only special XML chars, don't substitute chars by -- HTML entities, and don't generate empty elements for HTML elements, -- which may contain any contents, e.g. script -- src=.../script instead of script src=... -- / withOutputXHTML :: SysConfig -- | suppreses all char and entitiy substitution withOutputPLAIN :: SysConfig withXmlPi :: Bool -> SysConfig withNoEmptyElemFor :: [String] -> SysConfig withAddDefaultDTD :: Bool -> SysConfig withTextMode :: Bool -> SysConfig withShowTree :: Bool -> SysConfig withShowHaskell :: Bool -> SysConfig -- | Configure compression and decompression for binary -- serialization/deserialization. First component is the compression -- function applied after serialization, second the decompression applied -- before deserialization. withCompression :: (CompressionFct, DeCompressionFct) -> SysConfig yes :: Bool no :: Bool -- | system configuration and common options options module Text.XML.HXT.Arrow.XmlOptions -- | commonly useful options for XML input -- -- can be used for option definition with haskell getopt -- -- defines options: a_trace, a_proxy, a_use_curl, -- a_do_not_use_curl, a_options_curl, -- a_encoding, a_issue_errors, -- a_do_not_issue_errors, a_parse_html, -- a_parse_by_mimetype, a_issue_warnings, -- a_do_not_issue_warnings, a_parse_xml, a_validate, -- a_do_not_validate, a_canonicalize, -- a_do_not_canonicalize, inputOptions :: [OptDescr SysConfig] -- | commonly useful options for XML output -- -- defines options: a_indent, a_output_encoding, -- a_output_html and others outputOptions :: [OptDescr SysConfig] -- | commonly useful options -- -- defines options: a_verbose, a_help generalOptions :: [OptDescr SysConfig] -- | defines a_version option versionOptions :: [OptDescr SysConfig] -- | debug output options showOptions :: [OptDescr SysConfig] a_add_default_dtd :: String a_canonicalize :: String a_check_namespaces :: String a_collect_errors :: String a_default_baseuri :: String a_do_not_canonicalize :: String a_do_not_check_namespaces :: String a_do_not_issue_errors :: String a_do_not_issue_warnings :: String a_do_not_preserve_comment :: String a_do_not_remove_whitespace :: String a_do_not_validate :: String a_error :: String a_error_log :: String a_help :: String a_if_modified_since :: String a_if_unmodified_since :: String a_ignore_encoding_errors :: String a_ignore_none_xml_contents :: String a_indent :: String a_issue_errors :: String a_issue_warnings :: String a_mime_types :: String a_no_empty_elements :: String a_no_empty_elem_for :: String a_no_redirect :: String a_no_xml_pi :: String a_output_file :: String a_output_xml :: String a_output_html :: String a_output_xhtml :: String a_output_plain :: String a_parse_by_mimetype :: String a_parse_html :: String a_parse_xml :: String a_preserve_comment :: String a_proxy :: String a_redirect :: String a_remove_whitespace :: String a_show_haskell :: String a_show_tree :: String a_strict_input :: String a_text_mode :: String a_trace :: String a_validate :: String a_verbose :: String a_accept_mimetypes :: String -- | select options from a predefined list of option desciptions selectOptions :: [String] -> [OptDescr a] -> [OptDescr a] removeOptions :: [String] -> [OptDescr a] -> [OptDescr a] -- | interface to the HXT XML and DTD parsers module Text.XML.HXT.Arrow.ParserInterface parseXmlDoc :: ArrowXml a => a (String, String) XmlTree parseXmlDTDPart :: ArrowXml a => a (String, XmlTree) XmlTree parseXmlContent :: ArrowXml a => a String XmlTree parseXmlDocEncodingSpec :: ArrowXml a => a XmlTree XmlTree removeEncodingSpec :: ArrowXml a => a XmlTree XmlTree parseXmlEntityEncodingSpec :: ArrowXml a => a XmlTree XmlTree parseXmlDTDdeclPart :: ArrowXml a => a XmlTree XmlTree parseXmlDTDdecl :: ArrowXml a => a XmlTree XmlTree parseXmlDTDEntityValue :: ArrowXml a => a XmlTree XmlTree parseXmlAttrValue :: ArrowXml a => String -> a XmlTree XmlTree parseXmlGeneralEntityValue :: ArrowXml a => String -> a XmlTree XmlTree parseHtmlDoc :: ArrowList a => a (String, String) XmlTree parseHtmlContent :: ArrowList a => a String XmlTree -- | substitution of all predefined XHTMT entities for none ASCII chars -- -- This arrow recurses through a whole XML tree and substitutes all -- entity refs within text nodes and attribute values by a text node -- containing of a single char corresponding to this entity. -- -- Unknown entity refs remain unchanged substHtmlEntityRefs :: ArrowList a => a XmlTree XmlTree -- | substitution of the five predefined XMT entities, works like -- substHtmlEntityRefs substXmlEntityRefs :: ArrowList a => a XmlTree XmlTree -- | the entity substitution arrow called from substXmlEntityRefs -- and substHtmlEntityRefs substEntityRefs :: ArrowList a => [(String, Int)] -> a XmlTree XmlTree -- | common edit arrows module Text.XML.HXT.Arrow.Edit -- | Applies some Canonical XML rules to a document tree. -- -- The rule differ slightly for canonical XML and XPath in handling of -- comments -- -- Note: This is not the whole canonicalization as it is specified by the -- W3C Recommendation. Adding attribute defaults or sorting attributes in -- lexicographic order is done by the transform function of -- module Text.XML.HXT.Validator.Validation. Replacing entities -- or line feed normalization is done by the parser. -- -- Rules: remove DTD parts, processing instructions, comments and -- substitute char refs in attribute values and text -- -- Not implemented yet: -- -- canonicalizeAllNodes :: ArrowList a => a XmlTree XmlTree -- | Canonicalize a tree for XPath Like canonicalizeAllNodes but -- comment nodes are not removed -- -- see canonicalizeAllNodes canonicalizeForXPath :: ArrowList a => a XmlTree XmlTree -- | Canonicalize the contents of a document -- -- substitutes all char refs in text and attribute values, removes CDATA -- section and combines all sequences of resulting text nodes into a -- single text node -- -- see canonicalizeAllNodes canonicalizeContents :: ArrowList a => a XmlTree XmlTree -- | Applies collapseXText recursively. -- -- see also : collapseXText collapseAllXText :: ArrowList a => a XmlTree XmlTree -- | Collects sequences of text nodes in the list of children of a node -- into one single text node. This is useful, e.g. after char and entity -- reference substitution collapseXText :: ArrowList a => a XmlTree XmlTree -- | apply an arrow to the input and convert the resulting XML trees into -- an XML escaped string -- -- This is a save variant for converting a tree into an XML string -- representation that is parsable with -- Text.XML.HXT.Arrow.ReadDocument. It is implemented with -- xshow, but xshow does no XML escaping. The XML escaping is done -- with escapeXmlDoc before xshow is applied. -- -- So the following law holds -- -- 
--   xshowEscape f >>> xread == f
--
xshowEscapeXml :: ArrowXml a => a n XmlTree -> a n String -- | escape all special XML chars into XML entity references or char -- references -- -- convert the special XML chars < and & in text nodes into -- prefefiened XML entity references, in attribute values also ', ", -- >, \n, \r and \t are converted into entity or char references, in -- comments nothing is converted (see XML standard 2.4, useful e.g. for -- JavaScript). escapeXmlDoc :: ArrowList a => a XmlTree XmlTree -- | escape all special HTML chars into XHTML entity references or char -- references -- -- convert the special XML chars < and & and all none ASCII chars -- in text nodes into prefefiened XML or XHTML entity references, in -- attribute values also ', ", >, \n, \r and \t are converted into -- entity or char references, in comments nothing is converted escapeHtmlDoc :: ArrowList a => a XmlTree XmlTree -- | convert a document into a Haskell representation (with show). -- -- Useful for debugging and trace output. see also : -- treeRepOfXmlDoc, numberLinesInXmlDoc haskellRepOfXmlDoc :: ArrowList a => a XmlTree XmlTree -- | convert a document into a text representation in tree form. -- -- Useful for debugging and trace output. see also : -- haskellRepOfXmlDoc, numberLinesInXmlDoc treeRepOfXmlDoc :: ArrowList a => a XmlTree XmlTree addHeadlineToXmlDoc :: ArrowXml a => a XmlTree XmlTree -- | filter for indenting a document tree for pretty printing. -- -- the tree is traversed for inserting whitespace for tag indentation. -- -- whitespace is only inserted or changed at places, where it isn't -- significant, is's not inserted between tags and text containing non -- whitespace chars. -- -- whitespace is only inserted or changed at places, where it's not -- significant. preserving whitespace may be controlled in a document -- tree by a tag attribute xml:space -- -- allowed values for this attribute are default | preserve. -- -- input is a complete document tree or a document fragment result is the -- semantically equivalent formatted tree. -- -- see also : removeDocWhiteSpace indentDoc :: ArrowXml a => a XmlTree XmlTree -- | convert a document into a text and add line numbers to the text -- representation. -- -- Result is a root node with a single text node as child. Useful for -- debugging and trace output. see also : haskellRepOfXmlDoc, -- treeRepOfXmlDoc numberLinesInXmlDoc :: ArrowList a => a XmlTree XmlTree preventEmptyElements :: ArrowList a => [String] -> Bool -> a XmlTree XmlTree -- | remove Comments: none when isCmt removeComment :: ArrowXml a => a XmlTree XmlTree -- | remove all comments recursively removeAllComment :: ArrowXml a => a XmlTree XmlTree -- | simple filter for removing whitespace. -- -- no check on sigificant whitespace, e.g. in HTML <pre>-elements, -- is done. -- -- see also : removeAllWhiteSpace, removeDocWhiteSpace removeWhiteSpace :: ArrowXml a => a XmlTree XmlTree -- | simple recursive filter for removing all whitespace. -- -- removes all text nodes in a tree that consist only of whitespace. -- -- see also : removeWhiteSpace, removeDocWhiteSpace removeAllWhiteSpace :: ArrowXml a => a XmlTree XmlTree -- | filter for removing all not significant whitespace. -- -- the tree traversed for removing whitespace between elements, that was -- inserted for indentation and readability. whitespace is only removed -- at places, where it's not significat preserving whitespace may be -- controlled in a document tree by a tag attribute xml:space -- -- allowed values for this attribute are default | preserve -- -- input is root node of the document to be cleaned up, output the -- semantically equivalent simplified tree -- -- see also : indentDoc, removeAllWhiteSpace removeDocWhiteSpace :: ArrowXml a => a XmlTree XmlTree -- | converts a CDATA section node into a normal text node transfCdata :: ArrowXml a => a XmlTree XmlTree -- | converts CDATA sections in whole document tree into normal text nodes transfAllCdata :: ArrowXml a => a XmlTree XmlTree -- | converts character references to normal text transfCharRef :: ArrowXml a => a XmlTree XmlTree -- | recursively converts all character references to normal text transfAllCharRef :: ArrowXml a => a XmlTree XmlTree rememberDTDAttrl :: ArrowList a => a XmlTree XmlTree addDefaultDTDecl :: ArrowList a => a XmlTree XmlTree hasXmlPi :: ArrowXml a => a XmlTree XmlTree -- | add an <?xml version="1.0"?> processing instruction if it's not -- already there addXmlPi :: ArrowXml a => a XmlTree XmlTree -- | add an encoding spec to the <?xml version="1.0"?> processing -- instruction addXmlPiEncoding :: ArrowXml a => String -> a XmlTree XmlTree -- | add an XHTML strict doctype declaration to a document -- -- add an XHTML transitional doctype declaration to a document -- -- add an XHTML frameset doctype declaration to a document -- -- add a doctype declaration to a document -- -- The arguments are the root element name, the PUBLIC id and the SYSTEM -- id addDoctypeDecl :: ArrowXml a => String -> String -> String -> a XmlTree XmlTree addXHtmlDoctypeStrict :: ArrowXml a => a XmlTree XmlTree -- | add an XHTML strict doctype declaration to a document addXHtmlDoctypeTransitional :: ArrowXml a => a XmlTree XmlTree addXHtmlDoctypeFrameset :: ArrowXml a => a XmlTree XmlTree -- | namespace specific arrows module Text.XML.HXT.Arrow.Namespace -- | attach all valid namespace declarations to the attribute list of -- element nodes. -- -- This arrow is useful for document processing, that requires access to -- all namespace declarations at any element node, but which cannot be -- done with a simple processWithNsEnv. attachNsEnv :: ArrowXml a => NsEnv -> a XmlTree XmlTree -- | does the real work for namespace cleanup. -- -- The parameter is used for collecting namespace uris and prefixes from -- the input tree cleanupNamespaces :: LA XmlTree (String, String) -> LA XmlTree XmlTree -- | collect all namespace declarations contained in a document -- -- apply getNamespaceDecl to a whole XmlTree collectNamespaceDecl :: LA XmlTree (String, String) -- | collect all (namePrefix, namespaceUri) pairs from a tree -- -- all qualified names are inspected, whether a namespace uri is defined, -- for these uris the prefix and uri is returned. This arrow is useful -- for namespace cleanup, e.g. for documents generated with XSLT. It can -- be used together with collectNamespaceDecl to -- cleanupNamespaces collectPrefixUriPairs :: LA XmlTree (String, String) -- | test whether an attribute node contains an XML Namespace declaration isNamespaceDeclAttr :: ArrowXml a => a XmlTree XmlTree -- | get the namespace prefix and the namespace URI out of an attribute -- tree with a namespace declaration (see isNamespaceDeclAttr) for -- all other nodes this arrow fails getNamespaceDecl :: ArrowXml a => a XmlTree (String, String) -- | process a document tree with an arrow, containing always the valid -- namespace environment as extra parameter. -- -- The namespace environment is implemented as a -- Data.AssocList.AssocList processWithNsEnv :: ArrowXml a => (NsEnv -> a XmlTree XmlTree) -> NsEnv -> a XmlTree XmlTree -- | process all element nodes of a document tree with an arrow, containing -- always the valid namespace environment as extra parameter. Attribute -- lists are not processed. -- -- See also: processWithNsEnv processWithNsEnvWithoutAttrl :: ArrowXml a => (NsEnv -> a XmlTree XmlTree) -> NsEnv -> a XmlTree XmlTree -- | propagate all namespace declarations "xmlns:ns=..." to all element and -- attribute nodes of a document. -- -- This arrow does not check for illegal use of namespaces. The real work -- is done by propagateNamespaceEnv. -- -- The arrow may be applied repeatedly if neccessary. propagateNamespaces :: ArrowXml a => a XmlTree XmlTree -- | generate unique namespaces and add all namespace declarations to all -- top nodes containing a namespace declaration Usually the top node -- containing namespace declarations is the root node, but this isn't -- mandatory. -- -- Calls cleanupNamespaces with collectNamespaceDecl uniqueNamespaces :: ArrowXml a => a XmlTree XmlTree -- | generate unique namespaces and add all namespace declarations for all -- prefix-uri pairs in all qualified names -- -- useful for cleanup of namespaces in generated documents. Calls -- cleanupNamespaces with collectNamespaceDecl <+> -- collectPrefixUriPairs uniqueNamespacesFromDeclAndQNames :: ArrowXml a => a XmlTree XmlTree -- | validate the namespace constraints in a whole tree. -- -- Result is the list of errors concerning namespaces. Predicates -- isWellformedQName, isWellformedQualifiedName, -- isDeclaredNamespace and isWellformedNSDecl are applied -- to the appropriate elements and attributes. validateNamespaces :: ArrowXml a => a XmlTree XmlTree -- | the trace arrows module Text.XML.HXT.Arrow.XmlState.TraceHandling -- | set the global trace level setTraceLevel :: Int -> IOStateArrow s b b -- | read the global trace level getTraceLevel :: IOStateArrow s b Int -- | set the global trace command. This command does the trace output setTraceCmd :: (Int -> String -> IO ()) -> IOStateArrow s b b -- | acces the command for trace output getTraceCmd :: IOStateArrow a b (Int -> String -> IO ()) -- | run an arrow with a given trace level, the old trace level is restored -- after the arrow execution withTraceLevel :: Int -> IOStateArrow s b c -> IOStateArrow s b c -- | apply a trace arrow and issue message to stderr trace :: Int -> IOStateArrow s b String -> IOStateArrow s b b -- | trace the current value transfered in a sequence of arrows. -- -- The value is formated by a string conversion function. This is a -- substitute for the old and less general traceString function traceValue :: Int -> (b -> String) -> IOStateArrow s b b -- | an old alias for traceValue traceString :: Int -> (b -> String) -> IOStateArrow s b b -- | issue a string message as trace traceMsg :: Int -> String -> IOStateArrow s b b -- | issue the source representation of a document if trace level >= 3 -- -- for better readability the source is formated with indentDoc traceSource :: IOStateArrow s XmlTree XmlTree -- | issue the tree representation of a document if trace level >= 4 traceTree :: IOStateArrow s XmlTree XmlTree -- | trace a main computation step issue a message when trace level >= -- 1, issue document source if level >= 3, issue tree when level is -- >= 4 traceDoc :: String -> IOStateArrow s XmlTree XmlTree traceOutputToStderr :: Int -> String -> IO () -- | the basic state arrows for URI handling module Text.XML.HXT.Arrow.XmlState.URIHandling -- | set the base URI of a document, used e.g. for reading includes, e.g. -- external entities, the input must be an absolute URI setBaseURI :: IOStateArrow s String String -- | read the base URI from the globale state getBaseURI :: IOStateArrow s b String -- | change the base URI with a possibly relative URI, can be used for -- evaluating the xml:base attribute. Returns the new absolute base URI. -- Fails, if input is not parsable with parseURIReference -- -- see also: setBaseURI, mkAbsURI changeBaseURI :: IOStateArrow s String String -- | set the default base URI, if parameter is null, the system base ( -- file:///<cwd>/ ) is used, else the parameter, must be -- called before any document is read setDefaultBaseURI :: String -> IOStateArrow s b String -- | get the default base URI getDefaultBaseURI :: IOStateArrow s b String -- | remember base uri, run an arrow and restore the base URI, used with -- external entity substitution runInLocalURIContext :: IOStateArrow s b c -> IOStateArrow s b c -- | parse a URI reference, in case of a failure, try to escape unescaped -- chars, convert backslashes to slashes for windows paths, and try -- parsing again parseURIReference' :: String -> Maybe URI -- | compute the absolut URI for a given URI and a base URI expandURIString :: String -> String -> Maybe String -- | arrow variant of expandURIString, fails if -- expandURIString returns Nothing expandURI :: ArrowXml a => a (String, String) String -- | arrow for expanding an input URI into an absolute URI using global -- base URI, fails if input is not a legal URI mkAbsURI :: IOStateArrow s String String -- | arrow for selecting the scheme (protocol) of the URI, fails if input -- is not a legal URI. -- -- See Network.URI for URI components getSchemeFromURI :: ArrowList a => a String String -- | arrow for selecting the registered name (host) of the URI, fails if -- input is not a legal URI getRegNameFromURI :: ArrowList a => a String String -- | arrow for selecting the port number of the URI without leading ':', -- fails if input is not a legal URI getPortFromURI :: ArrowList a => a String String -- | arrow for selecting the user info of the URI without trailing '@', -- fails if input is not a legal URI getUserInfoFromURI :: ArrowList a => a String String -- | arrow for computing the path component of an URI, fails if input is -- not a legal URI getPathFromURI :: ArrowList a => a String String -- | arrow for computing the query component of an URI, fails if input is -- not a legal URI getQueryFromURI :: ArrowList a => a String String -- | arrow for computing the fragment component of an URI, fails if input -- is not a legal URI getFragmentFromURI :: ArrowList a => a String String -- | arrow for computing the path component of an URI, fails if input is -- not a legal URI getPartFromURI :: ArrowList a => (URI -> String) -> a String String -- | This module provides all datatypes for DTD validation module Text.XML.HXT.DTDValidation.TypeDefs type XmlArrow = LA XmlTree XmlTree type XmlArrowS = LA XmlTree XmlTrees dtd_value :: Attributes -> String dtd_type :: Attributes -> String dtd_kind :: Attributes -> String dtd_modifier :: Attributes -> String dtd_default :: Attributes -> String dtd_name :: Attributes -> String isUnparsedEntity :: ArrowDTD a => a XmlTree XmlTree hasDTDAttrValue :: ArrowDTD a => String -> (String -> Bool) -> a XmlTree XmlTree isRequiredAttrKind :: ArrowDTD a => a XmlTree XmlTree isDefaultAttrKind :: ArrowDTD a => a XmlTree XmlTree isFixedAttrKind :: ArrowDTD a => a XmlTree XmlTree isMixedContentElement :: ArrowDTD a => a XmlTree XmlTree isEmptyElement :: ArrowDTD a => a XmlTree XmlTree isEnumAttrType :: ArrowDTD a => a XmlTree XmlTree isIdAttrType :: ArrowDTD a => a XmlTree XmlTree isIdRefAttrType :: ArrowDTD a => a XmlTree XmlTree isNotationAttrType :: ArrowDTD a => a XmlTree XmlTree isAttlistOfElement :: ArrowDTD a => String -> a XmlTree XmlTree valueOfDTD :: String -> XmlTree -> String valueOf :: String -> XmlTree -> String getDTDAttributes :: XmlTree -> Attributes isDTDDoctypeNode :: XmlTree -> Bool isDTDElementNode :: XmlTree -> Bool isDTDAttlistNode :: XmlTree -> Bool isDTDContentNode :: XmlTree -> Bool isDTDNameNode :: XmlTree -> Bool isElemNode :: XmlTree -> Bool nameOfAttr :: XmlTree -> String nameOfElem :: XmlTree -> String -- | infix operator for applying an arrow to a list of trees -- -- ($$) :: XmlArrow -> XmlTrees -> XmlTrees -- | create an error message msgToErr :: (String -> String) -> LA String XmlTree -- | This module provides functions for validating attributes. -- -- The main functions are: -- -- module Text.XML.HXT.DTDValidation.AttributeValueValidation -- | Checks if the attribute value meets the lexical constraints of its -- type. -- -- checkAttributeValue :: XmlTrees -> XmlTree -> XmlArrow -- | Normalizes an attribute value with respect to its type. (3.3.3 / p.29 -- in Spec) -- -- normalizeAttributeValue :: Maybe XmlTree -> String -> String -- | This module provides functions for validating the DTD of XML documents -- represented as XmlTree. -- -- Unlike other popular XML validation tools the validation process -- returns a list of errors instead of aborting after the first error was -- found. -- -- Unlike validation of the document, the DTD branch is traversed four -- times: -- -- module Text.XML.HXT.DTDValidation.DTDValidation -- | Removes doublicate declarations from the DTD, which first declaration -- is binding. This is the case for ATTLIST and ENTITY declarations. -- -- removeDoublicateDefs :: XmlArrow -- | Validate a DTD. -- -- validateDTD :: XmlArrow -- | This module provides functions for transforming XML documents -- represented as XmlTree with respect to its DTD. -- -- Transforming an XML document with respect to its DTD means: -- -- -- -- Note: Transformation should be started after validation. -- -- Before the document is validated, a lookup-table is build on the basis -- of the DTD which maps element names to their transformation functions. -- After this initialization phase the whole document is traversed in -- preorder and every element is transformed by the XmlFilter from the -- lookup-table. module Text.XML.HXT.DTDValidation.DocTransformation -- | filter for transforming the document. -- -- transform :: XmlTree -> XmlArrow -- | A module for regular expression matching, adapted for XML DTDs. -- -- This module is based on the module RE. module Text.XML.HXT.DTDValidation.XmlRE -- | Data type for regular expressions. data RE a -- | Checks if an input matched a regular expression. The function should -- be called after matches. -- -- Was the sentence used in matches in the language of the -- regular expression? -> matches e s == s `in` L(e)? -- -- checkRE :: Show a => RE a -> String -- | Derives a regular expression with respect to a list of elements. -- -- matches :: RE String -> XmlTrees -> RE String -- | Constructs a string representation of a regular expression. -- -- printRE :: Show a => RE a -> String -- | Constructs a regular expression for an empty sequence. -- -- re_unit :: RE a -- | Constructs a regular expression for an empty set. -- -- re_zero :: String -> RE a -- | Constructs a regular expression for accepting a symbol -- -- re_sym :: a -> RE a -- | Constructs an optional repetition (*) of a regular expression -- -- re_rep :: RE a -> RE a -- | Constructs a repetition (+) of a regular expression -- -- re_plus :: RE a -> RE a -- | Constructs an option (?) of a regular expression -- -- re_opt :: RE a -> RE a -- | Constructs a sequence (,) of two regular expressions -- -- re_seq :: RE a -> RE a -> RE a -- | Constructs an alternative (|) of two regular expressions -- -- re_alt :: RE a -> RE a -> RE a -- | Constructs a regular expression for accepting any singel symbol -- -- re_dot :: RE a -- | This module provides functions for validating XML Documents -- represented as XmlTree. -- -- Unlike other popular XML validation tools the validation process -- returns a list of errors instead of aborting after the first error was -- found. -- -- Before the document is validated, a lookup-table is build on the basis -- of the DTD which maps element names to their validation functions. -- After this initialization phase the whole document is traversed in -- preorder and every element is validated by the XmlFilter from the -- lookup-table. module Text.XML.HXT.DTDValidation.DocValidation -- | Validate a document. -- -- validateDoc :: XmlTree -> XmlArrow -- | This module provides functions for checking special -- IDIDREFIDREFS constraints. -- -- Checking special ID/IDREF/IDREFS constraints means: -- -- -- -- ID-Validation should be started before or after validating the -- document. -- -- First all nodes with ID attributes are collected from the document, -- then it is validated that values of ID attributes do not occure more -- than once. During a second iteration over the document it is validated -- that there exists an ID attribute value for IDREF/IDREFS attribute -- values. module Text.XML.HXT.DTDValidation.IdValidation -- | Perform the validation of the IDIDREFIDREFS constraints. -- -- validateIds :: XmlTree -> XmlArrow -- | This module provides functions for validating XML documents -- represented as XmlTree. -- -- Unlike other popular XML validation tools the validation functions -- return a list of errors instead of aborting after the first error was -- found. -- -- Note: The validation process has been split into validation and -- transformation! If validate did not report any errors, -- transform should be called, to change the document the way a -- validating parser is expected to do. module Text.XML.HXT.DTDValidation.Validation getDTDSubset :: XmlArrow -- | Main validation filter. Check if the DTD and the document are valid. -- -- validate :: XmlArrow -- | Check if the DTD is valid. -- -- validateDTD :: XmlArrow -- | Check if the document corresponds to the given DTD. -- -- validateDoc :: XmlArrow -- | Removes doublicate declarations from the DTD which first declaration -- is binding. This is the case for ATTLIST and ENTITY declarations. -- -- removeDoublicateDefs :: XmlArrow -- | filter for transforming a document with respect to the given DTD. -- -- Validating parsers are expected to normalize attribute values and add -- default values. This function should be called after a successful -- validation. -- -- transform :: XmlArrow -- | run an io state arrow module Text.XML.HXT.Arrow.XmlState.RunIOStateArrow -- | apply an IOSArrow to an empty root node with -- initialState () as initial state -- -- the main entry point for running a state arrow with IO -- -- when running runX f an empty XML root node is applied to -- f. usually f will start with a constant arrow -- (ignoring the input), e.g. a -- Text.XML.HXT.Arrow.ReadDocument.readDocument arrow. -- -- for usage see examples with -- Text.XML.HXT.Arrow.WriteDocument.writeDocument -- -- if input has to be feed into the arrow use runIOSLA like in -- runIOSLA f emptyX inputDoc runX :: IOSArrow XmlTree c -> IO [c] runXIOState :: XIOState s -> IOStateArrow s XmlTree c -> IO [c] -- | the default global state, used as initial state when running an -- IOSArrow with runIOSLA or runX initialState :: us -> XIOState us initialSysState :: XIOSysState initialSysWriter :: XIOSysWriter initialSysEnv :: XIOSysEnv initialInputConfig :: XIOInputConfig initialParseConfig :: XIOParseConfig initialOutputConfig :: XIOOutputConfig initialRelaxConfig :: XIORelaxConfig initialCacheConfig :: XIOCacheConfig dummyHTTPHandler :: IOSArrow XmlTree XmlTree dummyTagSoupParser :: IOSArrow b b dummyRelaxValidator :: IOSArrow b b dummyCacheRead :: String -> IOSArrow b b getConfigAttr :: String -> SysConfigList -> String theSysConfigComp :: Selector XIOSysState a -> Selector SysConfig a -- | the interface for the basic state maipulation functions module Text.XML.HXT.Arrow.XmlState -- | state datatype consists of a system state and a user state the user -- state is not fixed data XIOState us -- | predefined system state data type with all components for the system -- functions, like trace, error handling, ... data XIOSysState -- | The arrow type for stateful arrows type IOStateArrow s b c = IOSLA (XIOState s) b c -- | The arrow for stateful arrows with no user defined state type IOSArrow b c = IOStateArrow () b c type SysConfig = XIOSysState -> XIOSysState type SysConfigList = [SysConfig] -- | read the user defined part of the state getUserState :: IOStateArrow s b s -- | set the user defined part of the state setUserState :: IOStateArrow s s s -- | change the user defined part of the state changeUserState :: (b -> s -> s) -> IOStateArrow s b b -- | extend user state -- -- Run an arrow with an extended user state component, The old component -- is stored together with a new one in a pair, the arrow is executed -- with this extended state, and the augmented state component is removed -- form the state when the arrow has finished its execution withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c -- | change the type of user state -- -- This conversion is useful, when running a state arrow with another -- structure of the user state, e.g. with () when executing some IO -- arrows withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c -- | apply an IOSArrow to an empty root node with -- initialState () as initial state -- -- the main entry point for running a state arrow with IO -- -- when running runX f an empty XML root node is applied to -- f. usually f will start with a constant arrow -- (ignoring the input), e.g. a -- Text.XML.HXT.Arrow.ReadDocument.readDocument arrow. -- -- for usage see examples with -- Text.XML.HXT.Arrow.WriteDocument.writeDocument -- -- if input has to be feed into the arrow use runIOSLA like in -- runIOSLA f emptyX inputDoc runX :: IOSArrow XmlTree c -> IO [c] configSysVars :: SysConfigList -> IOStateArrow s c c -- | store a string in global state under a given attribute name setSysAttr :: String -> IOStateArrow s String String -- | remove an entry in global state, arrow input remains unchanged unsetSysAttr :: String -> IOStateArrow s b b -- | read an attribute value from global state getSysAttr :: String -> IOStateArrow s b String -- | read all attributes from global state getAllSysAttrs :: IOStateArrow s b Attributes setSysAttrString :: String -> String -> IOStateArrow s b b -- | store an int value in global state setSysAttrInt :: String -> Int -> IOStateArrow s b b -- | read an int value from global state -- -- 
--   getSysAttrInt 0 myIntAttr
--
getSysAttrInt :: Int -> String -> IOStateArrow s b Int getConfigAttr :: String -> SysConfigList -> String -- | reset global error variable clearErrStatus :: IOStateArrow s b b -- | set global error variable setErrStatus :: IOStateArrow s Int Int -- | read current global error status getErrStatus :: IOStateArrow s XmlTree Int -- | raise the global error status level to that of the input tree setErrMsgStatus :: IOStateArrow s XmlTree XmlTree -- | set the error message handler and the flag for collecting the errors setErrorMsgHandler :: Bool -> (String -> IO ()) -> IOStateArrow s b b -- | the default error message handler: error output to stderr errorMsgStderr :: IOStateArrow s b b -- | error message handler for collecting errors errorMsgCollect :: IOStateArrow s b b -- | error message handler for output to stderr and collecting errorMsgStderrAndCollect :: IOStateArrow s b b -- | error message handler for ignoring errors errorMsgIgnore :: IOStateArrow s b b -- | if error messages are collected by the error handler for processing -- these messages by the calling application, this arrow reads the stored -- messages and clears the error message store getErrorMessages :: IOStateArrow s b XmlTree -- | filter error messages from input trees and issue errors filterErrorMsg :: IOStateArrow s XmlTree XmlTree -- | generate a warnig message issueWarn :: String -> IOStateArrow s b b -- | generate an error message issueErr :: String -> IOStateArrow s b b -- | generate a fatal error message, e.g. document not found issueFatal :: String -> IOStateArrow s b b -- | Default exception handler: issue a fatal error message and fail. -- -- The parameter can be used to specify where the error occured issueExc :: String -> IOStateArrow s SomeException b -- | add the error level and the module where the error occured to the -- attributes of a document root node and remove the children when level -- is greater or equal to c_err. called by -- setDocumentStatusFromSystemState when the system state -- indicates an error setDocumentStatus :: Int -> String -> IOStateArrow s XmlTree XmlTree -- | check whether the error level attribute in the system state is set to -- error, in this case the children of the document root are removed and -- the module name where the error occured and the error level are added -- as attributes with setDocumentStatus else nothing is changed setDocumentStatusFromSystemState :: String -> IOStateArrow s XmlTree XmlTree -- | check whether tree is a document root and the status attribute has a -- value less than c_err documentStatusOk :: ArrowXml a => a XmlTree XmlTree -- | set the global trace level setTraceLevel :: Int -> IOStateArrow s b b -- | read the global trace level getTraceLevel :: IOStateArrow s b Int -- | run an arrow with a given trace level, the old trace level is restored -- after the arrow execution withTraceLevel :: Int -> IOStateArrow s b c -> IOStateArrow s b c -- | set the global trace command. This command does the trace output setTraceCmd :: (Int -> String -> IO ()) -> IOStateArrow s b b -- | acces the command for trace output getTraceCmd :: IOStateArrow a b (Int -> String -> IO ()) -- | apply a trace arrow and issue message to stderr trace :: Int -> IOStateArrow s b String -> IOStateArrow s b b -- | issue a string message as trace traceMsg :: Int -> String -> IOStateArrow s b b -- | trace the current value transfered in a sequence of arrows. -- -- The value is formated by a string conversion function. This is a -- substitute for the old and less general traceString function traceValue :: Int -> (b -> String) -> IOStateArrow s b b -- | an old alias for traceValue traceString :: Int -> (b -> String) -> IOStateArrow s b b -- | issue the source representation of a document if trace level >= 3 -- -- for better readability the source is formated with indentDoc traceSource :: IOStateArrow s XmlTree XmlTree -- | issue the tree representation of a document if trace level >= 4 traceTree :: IOStateArrow s XmlTree XmlTree -- | trace a main computation step issue a message when trace level >= -- 1, issue document source if level >= 3, issue tree when level is -- >= 4 traceDoc :: String -> IOStateArrow s XmlTree XmlTree -- | set the base URI of a document, used e.g. for reading includes, e.g. -- external entities, the input must be an absolute URI setBaseURI :: IOStateArrow s String String -- | read the base URI from the globale state getBaseURI :: IOStateArrow s b String -- | change the base URI with a possibly relative URI, can be used for -- evaluating the xml:base attribute. Returns the new absolute base URI. -- Fails, if input is not parsable with parseURIReference -- -- see also: setBaseURI, mkAbsURI changeBaseURI :: IOStateArrow s String String -- | set the default base URI, if parameter is null, the system base ( -- file:///<cwd>/ ) is used, else the parameter, must be -- called before any document is read setDefaultBaseURI :: String -> IOStateArrow s b String -- | get the default base URI getDefaultBaseURI :: IOStateArrow s b String -- | remember base uri, run an arrow and restore the base URI, used with -- external entity substitution runInLocalURIContext :: IOStateArrow s b c -> IOStateArrow s b c -- | compute the absolut URI for a given URI and a base URI expandURIString :: String -> String -> Maybe String -- | arrow variant of expandURIString, fails if -- expandURIString returns Nothing expandURI :: ArrowXml a => a (String, String) String -- | arrow for expanding an input URI into an absolute URI using global -- base URI, fails if input is not a legal URI mkAbsURI :: IOStateArrow s String String -- | arrow for computing the fragment component of an URI, fails if input -- is not a legal URI getFragmentFromURI :: ArrowList a => a String String -- | arrow for computing the path component of an URI, fails if input is -- not a legal URI getPathFromURI :: ArrowList a => a String String -- | arrow for selecting the port number of the URI without leading ':', -- fails if input is not a legal URI getPortFromURI :: ArrowList a => a String String -- | arrow for computing the query component of an URI, fails if input is -- not a legal URI getQueryFromURI :: ArrowList a => a String String -- | arrow for selecting the registered name (host) of the URI, fails if -- input is not a legal URI getRegNameFromURI :: ArrowList a => a String String -- | arrow for selecting the scheme (protocol) of the URI, fails if input -- is not a legal URI. -- -- See Network.URI for URI components getSchemeFromURI :: ArrowList a => a String String -- | arrow for selecting the user info of the URI without trailing '@', -- fails if input is not a legal URI getUserInfoFromURI :: ArrowList a => a String String -- | read the system mimetype table getMimeTypeTable :: IOStateArrow s b MimeTypeTable -- | set the table mapping of file extensions to mime types in the system -- state -- -- Default table is defined in -- Text.XML.HXT.DOM.MimeTypeDefaults. This table is used when -- reading loacl files, (file: protocol) to determine the mime type setMimeTypeTable :: MimeTypeTable -> IOStateArrow s b b -- | set the table mapping of file extensions to mime types by an external -- config file -- -- The config file must follow the conventions of etcmime.types on -- a debian linux system, that means all empty lines and all lines -- starting with a # are ignored. The other lines must consist of a mime -- type followed by a possible empty list of extensions. The list of -- extenstions and mime types overwrites the default list in the system -- state of the IOStateArrow setMimeTypeTableFromFile :: FilePath -> IOStateArrow s b b yes :: Bool no :: Bool withAcceptedMimeTypes :: [String] -> SysConfig withAddDefaultDTD :: Bool -> SysConfig -- | withSysAttr key value : store an arbitarty key value pair in -- system state withSysAttr :: String -> String -> SysConfig -- | withCanonicalize yes/no : read option, canonicalize document, -- default is yes withCanonicalize :: Bool -> SysConfig -- | Configure compression and decompression for binary -- serialization/deserialization. First component is the compression -- function applied after serialization, second the decompression applied -- before deserialization. withCompression :: (CompressionFct, DeCompressionFct) -> SysConfig -- | withCheckNamespaces yes/no: read option, check namespaces, -- default is no withCheckNamespaces :: Bool -> SysConfig -- | withDefaultBaseURI URI , input option, set the default base -- URI -- -- This option can be useful when parsing documents from stdin or -- contained in a string, and interpreting relative URIs within the -- document withDefaultBaseURI :: String -> SysConfig -- | withEncodingErrors yes/no : input option, ignore all encoding -- errors, default is no withEncodingErrors :: Bool -> SysConfig -- | withErrors yes/no : system option for suppressing error -- messages, default is no withErrors :: Bool -> SysConfig -- | withIgnoreNoneXmlContents yes/no : input option, ignore -- document contents of none XML/HTML documents. -- -- This option can be useful for implementing crawler like applications, -- e.g. an URL checker. In those cases net traffic can be reduced. withIgnoreNoneXmlContents :: Bool -> SysConfig -- | withIndent yes/no : output option, indent document before -- output, default is no withIndent :: Bool -> SysConfig -- | withInputEncoding encodingName : input option -- -- Set default document encoding (utf8, isoLatin1, -- usAscii, iso8859_2, ... , iso8859_16, ...). Only -- XML, HTML and text documents are decoded, default decoding for -- XML/HTML is utf8, for text iso latin1 (no decoding). withInputEncoding :: String -> SysConfig withInputOption :: String -> String -> SysConfig withInputOptions :: Attributes -> SysConfig -- | withMimeTypeFile filename : input option, set the mime type -- table for file: documents by given file. The format of this -- config file must be in the syntax of a debian linux "mime.types" -- config file withMimeTypeFile :: String -> SysConfig withNoEmptyElemFor :: [String] -> SysConfig withXmlPi :: Bool -> SysConfig -- | withOutputEncoding encoding , output option, default is the -- default input encoding or utf8, if input encoding is not set withOutputEncoding :: String -> SysConfig -- | withOutputXML : output option, default writing -- -- Default is writing XML: quote special XML chars >,<,",',& -- where neccessary, add XML processing instruction and encode document -- with respect to withOutputEncoding withOutputXML :: SysConfig -- | Write XHTML: quote all special XML chars, use HTML entity refs or char -- refs for none ASCII chars withOutputHTML :: SysConfig -- | Write XML: quote only special XML chars, don't substitute chars by -- HTML entities, and don't generate empty elements for HTML elements, -- which may contain any contents, e.g. script -- src=.../script instead of script src=... -- / withOutputXHTML :: SysConfig -- | suppreses all char and entitiy substitution withOutputPLAIN :: SysConfig -- | withParseByMimeType yes/no : read option, select the parser -- by the mime type of the document (pulled out of the HTTP header). -- -- When the mime type is set to "text/html" the configured HTML parser is -- taken, when it's set to "text/xml" or "text/xhtml" the configured XML -- parser is taken. If the mime type is something else, no further -- processing is performed, the contents is given back to the application -- in form of a single text node. If the default document encoding is set -- to isoLatin1, this even enables processing of arbitray binary data. withParseByMimeType :: Bool -> SysConfig -- | withParseHTML yes/no: read option, use HTML parser, default -- is no (use XML parser) withParseHTML :: Bool -> SysConfig -- | withPreserveComment yes/no : read option, preserve comments -- during canonicalization, default is no withPreserveComment :: Bool -> SysConfig -- | withProxy "host:port" : input option, configure a proxy for -- HTTP access, e.g. www-cache:3128 withProxy :: String -> SysConfig -- | withRedirect yes/no : input option, automatically follow -- redirected URIs, default is yes withRedirect :: Bool -> SysConfig -- | withRemoveWS yes/no : read and write option, remove all -- whitespace, used for document indentation, default is no withRemoveWS :: Bool -> SysConfig withShowHaskell :: Bool -> SysConfig withShowTree :: Bool -> SysConfig -- | withStrictInput yes/no : input option, input of file and HTTP -- contents is read eagerly, default is no withStrictInput :: Bool -> SysConfig withTextMode :: Bool -> SysConfig -- | withTace level : system option, set the trace level, (0..4) withTrace :: Int -> SysConfig -- | withValidate yes/no: read option, validate document againsd -- DTD, default is yes withValidate :: Bool -> SysConfig -- | withWarnings yes/no : system option, issue warnings during -- reading, HTML parsing and processing, default is yes withWarnings :: Bool -> SysConfig -- | State arrows for document input module Text.XML.HXT.Arrow.DocumentInput getURIContents :: IOStateArrow s XmlTree XmlTree -- | Read the content of a document. -- -- This routine is usually called from -- Text.XML.HXT.Arrow.ProcessDocument.getDocumentContents. -- -- The input must be a root node (constructed with root), usually -- without children. The attribute list contains all input parameters, -- e.g. URI or source file name, encoding preferences, ... If the source -- name is empty, the input is read from standard input. -- -- The source is transformed into an absolute URI. If the source is a -- relative URI, or a file name, it is expanded into an absolut URI with -- respect to the current base URI. The default base URI is of protocol -- "file" and points to the current working directory. -- -- The currently supported protocols are "http", "file", "stdin" and -- "string". -- -- The latter two are internal protocols. An uri of the form "stdin:" -- stands for the content of the standard input stream. -- -- "string:some text" means, that "some text" is taken as input. This -- internal protocol is used for reading from normal String -- values. getXmlContents :: IOStateArrow s XmlTree XmlTree getXmlEntityContents :: IOStateArrow s XmlTree XmlTree getEncoding :: IOStateArrow s XmlTree String getTextEncoding :: IOStateArrow s XmlTree String decodeDocument :: IOStateArrow s XmlTree XmlTree addInputError :: Attributes -> String -> IOStateArrow s XmlTree XmlTree -- | DTD processing function for including external parts of a DTD -- parameter entity substitution and general entity substitution -- -- Implemtation completely done with arrows module Text.XML.HXT.Arrow.DTDProcessing -- | a filter for DTD processing -- -- inclusion of external parts of DTD, parameter entity substitution -- conditional section evaluation -- -- input tree must represent a complete document including root node processDTD :: IOStateArrow s XmlTree XmlTree instance Eq DTDPart -- | State arrows for document output module Text.XML.HXT.Arrow.DocumentOutput putXmlDocument :: Bool -> String -> IOStateArrow s XmlTree XmlTree -- | write the tree representation of a document to a file putXmlTree :: String -> IOStateArrow s XmlTree XmlTree -- | write a document with indentaion and line numers putXmlSource :: String -> IOStateArrow s XmlTree XmlTree encodeDocument :: Bool -> String -> IOStateArrow s XmlTree XmlTree encodeDocument' :: ArrowXml a => Bool -> String -> a XmlTree XmlTree -- | general entity substitution module Text.XML.HXT.Arrow.GeneralEntitySubstitution -- | substitution of general entities -- -- input: a complete document tree including root node processGeneralEntities :: IOStateArrow s XmlTree XmlTree -- | Compound arrows for reading, parsing, validating and writing XML -- documents -- -- All arrows use IO and a global state for options, errorhandling, ... module Text.XML.HXT.Arrow.ProcessDocument -- | XML parser -- -- Input tree must be a root tree with a text tree as child containing -- the document to be parsed. The parser generates from the input string -- a tree of a wellformed XML document, processes the DTD (parameter -- substitution, conditional DTD parts, ...) and substitutes all general -- entity references. Next step is character reference substitution. Last -- step is the document validation. Validation can be controlled by an -- extra parameter. -- -- Example: -- -- 
--   parseXmlDocument True    -- parse and validate document
--   
--   parseXmlDocument False   -- only parse document, don't validate
--
-- -- This parser is useful for applications processing correct XML -- documents. parseXmlDocument :: Bool -> IOStateArrow s XmlTree XmlTree -- | HTML parser -- -- Input tree must be a root tree with a text tree as child containing -- the document to be parsed. The parser tries to parse everything as -- HTML, if the HTML document is not wellformed XML or if errors occur, -- warnings are generated. The warnings can be issued, or suppressed. -- -- Example: parseHtmlDocument True : parse document and issue -- warnings -- -- This parser is useful for applications like web crawlers, where the -- pages may contain arbitray errors, but the application is only -- interested in parts of the document, e.g. the plain text. parseHtmlDocument :: IOStateArrow s XmlTree XmlTree -- | Document validation -- -- Input must be a complete document tree. The document is validated with -- respect to the DTD spec. Only useful for XML documents containing a -- DTD. -- -- If the document is valid, it is transformed with respect to the DTD, -- normalization of attribute values, adding default values, sorting -- attributes by name,... -- -- If no error was found, result is the normalized tree, else the error -- status is set in the list of attributes of the root node "/" and the -- document content is removed from the tree. validateDocument :: IOStateArrow s XmlTree XmlTree -- | Namespace propagation -- -- Input must be a complete document tree. The namespace declarations are -- evaluated and all element and attribute names are processed by -- splitting the name into prefix, local part and namespace URI. -- -- Naames are checked with respect to the XML namespace definition -- -- If no error was found, result is the unchanged input tree, else the -- error status is set in the list of attributes of the root node "/" and -- the document content is removed from the tree. propagateAndValidateNamespaces :: IOStateArrow s XmlTree XmlTree andValidateNamespaces :: IOStateArrow s XmlTree XmlTree -- | creates a new document root, adds all options as attributes to the -- document root and calls getXmlContents. -- -- If the document name is the empty string, the document will be read -- from standard input. -- -- For supported protocols see getXmlContents getDocumentContents :: String -> IOStateArrow s b XmlTree -- | Compound arrow for writing XML documents module Text.XML.HXT.Arrow.WriteDocument -- | the main filter for writing documents -- -- this filter can be configured by an option list like -- Text.XML.HXT.Arrow.ReadDocument.readDocument -- -- usage: writeDocument optionList destination -- -- if destination is the empty string or "-", stdout is used -- as output device -- -- for available options see -- Text.XML.HXT.Arrow.XmlState.SystemConfig -- -- -- -- a minimal main program for copying a document has the following -- structure: -- -- 
--   module Main
--   where
--   
--   import Text.XML.HXT.Core
--   
--   main        :: IO ()
--   main
--       = do
--         runX ( readDocument  [] "hello.xml"
--                >>>
--                writeDocument [] "bye.xml"
--              )
--         return ()
--
-- -- an example for copying a document from the web to standard output with -- global trace level 1, input trace level 2, output encoding isoLatin1, -- and evaluation of error code is: -- -- 
--   module Main
--   where
--   
--   import Text.XML.HXT.Core
--   import Text.XML.HXT.Curl
--   -- or
--   -- import Text.XML.HXT.HTTP
--   import System.Exit
--   
--   main        :: IO ()
--   main
--       = do
--         [rc] <- runX
--                 ( configSysVars [ withTrace 1          -- set the defaults for all read-,
--                                 , withCurl []          -- write- and other operations
--                                   -- or withHTTP []
--                                 ]
--                   >>>
--                   readDocument  [ withTrace     2      -- use these additional
--                                 , withParseHTML yes    -- options only for this read
--                                 ]
--                                 "http://www.haskell.org/"
--                   >>>
--                   writeDocument [ withOutputEncoding isoLatin1
--                                 ]
--                                 ""                     -- output to stdout
--                   >>>
--                   getErrStatus
--                 )
--         exitWith ( if rc >= c_err
--                    then ExitFailure 1
--                    else ExitSuccess
--                  )
--
writeDocument :: SysConfigList -> String -> IOStateArrow s XmlTree XmlTree writeDocument' :: Bool -> String -> IOStateArrow s XmlTree XmlTree -- | Convert a document into a string. Formating is done the same way and -- with the same options as in writeDocument. Default output -- encoding is no encoding, that means the result is a normal unicode -- encode haskell string. The default may be overwritten with the -- Text.XML.HXT.Arrow.XmlState.SystemConfig.withOutputEncoding -- option. The XML PI can be suppressed by the -- Text.XML.HXT.XmlKeywords.a_no_xml_pi option. -- -- This arrow fails, when the encoding scheme is not supported. The arrow -- is pure, it does not run in the IO monad. The XML PI is suppressed, if -- not explicitly turned on with an option (a_no_xml_pi, v_0) writeDocumentToString :: ArrowXml a => SysConfigList -> a XmlTree String -- | indent and format output prepareContents :: ArrowXml a => XIOSysState -> (Bool -> String -> a XmlTree XmlTree) -> a XmlTree XmlTree -- | Module for importing all list arrows module Control.Arrow.ListArrows -- | Compound arrows for reading an XML/HTML document or an XML/HTML string module Text.XML.HXT.Arrow.ReadDocument -- | the main document input filter -- -- this filter can be configured by a list of configuration options, a -- value of type Text.XML.HXT.XmlState.TypeDefs.SysConfig -- -- for all available options see module -- Text.XML.HXT.XmlState.SystemConfig -- -- -- -- examples: -- -- 
--   readDocument [] "test.xml"
--
-- -- reads and validates a document "test.xml", no namespace propagation, -- only canonicalization is performed -- -- 
--   ...
--   import Text.XML.HXT.Curl
--   ...
--   
--   readDocument [ withValidate        no
--                , withInputEncoding   isoLatin1
--                , withParseByMimeType yes
--                , withCurl []
--                ] \"http:\/\/localhost\/test.php\"
--
-- -- reads document "test.php", parses it as HTML or XML depending on the -- mimetype given from the server, but without validation, default -- encoding isoLatin1. HTTP access is done via libCurl. -- -- 
--   readDocument [ withParseHTML       yes
--                , withInputEncoding   isoLatin1
--                ] ""
--
-- -- reads a HTML document from standard input, no validation is done when -- parsing HTML, default encoding is isoLatin1, -- -- 
--   readDocument [ withInputEncoding  isoLatin1
--                , withValidate       no
--                , withMimeTypeFile   "/etc/mime.types"
--                , withStrictInput    yes
--                ] "test.svg"
--
-- -- reads an SVG document from "test.svg", sets the mime type by looking -- in the system mimetype config file, default encoding is -- isoLatin1, -- -- 
--   ...
--   import Text.XML.HXT.Curl
--   import Text.XML.HXT.TagSoup
--   ...
--   
--   readDocument [ withParseHTML      yes
--                , withTagSoup
--                , withProxy          "www-cache:3128"
--                , withCurl           []
--                , withWarnings       no
--                ] "http://www.haskell.org/"
--
-- -- reads Haskell homepage with HTML parser, ignoring any warnings (at the -- time of writing, there were some HTML errors), with http access via -- libCurl interface and proxy "www-cache" at port 3128, parsing is done -- with tagsoup HTML parser. This requires packages "hxt-curl" and -- "hxt-tagsoup" to be installed -- -- 
--   readDocument [ withValidate          yes
--                , withCheckNamespaces   yes
--                , withRemoveWS          yes
--                , withTrace             2
--                , withHTTP              []
--                ] "http://www.w3c.org/"
--
-- -- read w3c home page (xhtml), validate and check namespaces, remove -- whitespace between tags, trace activities with level 2. HTTP access is -- done with Haskell HTTP package -- -- for minimal complete examples see -- Text.XML.HXT.Arrow.WriteDocument.writeDocument and -- runX, the main starting point for running an XML arrow. readDocument :: SysConfigList -> String -> IOStateArrow s b XmlTree -- | the arrow version of readDocument, the arrow input is the -- source URI readFromDocument :: SysConfigList -> IOStateArrow s String XmlTree -- | read a document that is stored in a normal Haskell String -- -- the same function as readDocument, but the parameter forms the input. -- All options available for readDocument are applicable for -- readString. -- -- Default encoding: No encoding is done, the String argument is taken as -- Unicode string readString :: SysConfigList -> String -> IOStateArrow s b XmlTree -- | the arrow version of readString, the arrow input is the source -- URI readFromString :: SysConfigList -> IOStateArrow s String XmlTree -- | parse a string as HTML content, substitute all HTML entity refs and -- canonicalize tree (substitute char refs, ...). Errors are ignored. -- -- A simpler version of readFromString but with less -- functionality. Does not run in the IO monad hread :: ArrowXml a => a String XmlTree -- | parse a string as XML content, substitute all predefined XML entity -- refs and canonicalize tree (substitute char refs, ...) xread :: ArrowXml a => a String XmlTree -- | Pickler functions for converting between user defined data types and -- XmlTree data. Usefull for persistent storage and retreival of arbitray -- data as XML documents -- -- This module is an adaptation of the pickler combinators developed by -- Andrew Kennedy ( -- http://research.microsoft.com/~akenn/fun/picklercombinators.pdf ) -- -- The difference to Kennedys approach is that the target is not a list -- of Chars but a list of XmlTrees. The basic picklers will convert data -- into XML text nodes. New are the picklers for creating elements and -- attributes. -- -- One extension was neccessary: The unpickling may fail. Therefore the -- unpickler has a Maybe result type. Failure is used to unpickle -- optional elements (Maybe data) and lists of arbitray length -- -- There is an example program demonstrating the use of the picklers for -- a none trivial data structure. (see "examples/arrows/pickle" -- directory) module Text.XML.HXT.Arrow.Pickle.Xml data St St :: [XmlTree] -> [XmlTree] -> St attributes :: St -> [XmlTree] contents :: St -> [XmlTree] data PU a PU :: ((a, St) -> St) -> (St -> (Maybe a, St)) -> Schema -> PU a appPickle :: PU a -> (a, St) -> St appUnPickle :: PU a -> St -> (Maybe a, St) theSchema :: PU a -> Schema emptySt :: St addAtt :: XmlTree -> St -> St addCont :: XmlTree -> St -> St dropCont :: St -> St getAtt :: QName -> St -> Maybe XmlTree getCont :: St -> Maybe XmlTree -- | conversion of an arbitrary value into an XML document tree. -- -- The pickler, first parameter, controls the conversion process. Result -- is a complete document tree including a root node pickleDoc :: PU a -> a -> XmlTree -- | Conversion of an XML document tree into an arbitrary data type -- -- The inverse of pickleDoc. This law should hold for all -- picklers: unpickle px . pickle px $ v == Just v . Not every -- possible combination of picklers make sense. For reconverting a value -- from an XML tree, is becomes neccessary, to introduce "enough" markup -- for unpickling the value unpickleDoc :: PU a -> XmlTree -> Maybe a -- | Pickles a value, then writes the document to a string. showPickled :: XmlPickler a => SysConfigList -> a -> String -- | The zero pickler -- -- Encodes nothing, fails always during unpickling xpZero :: PU a xpUnit :: PU () -- | Lift a value to a pickler -- -- When pickling, nothing is encoded, when unpickling, the given value is -- inserted. This pickler always succeeds. xpLift :: a -> PU a -- | Lift a Maybe value to a pickler. -- -- Nothing is mapped to the zero pickler, Just x is -- pickled with xpLift x. xpLiftMaybe :: Maybe a -> PU a -- | pickle/unpickle combinator for sequence and choice. -- -- When the first unpickler fails, the second one is taken, else the -- third one configured with the result from the first is taken. This -- pickler is a generalisation for xpSeq and xpChoice . -- -- The schema must be attached later, e.g. in xpPair or other higher -- level combinators xpCondSeq :: PU b -> (b -> a) -> PU a -> (a -> PU b) -> PU b -- | Combine two picklers sequentially. -- -- If the first fails during unpickling, the whole unpickler fails xpSeq :: (b -> a) -> PU a -> (a -> PU b) -> PU b -- | combine tow picklers with a choice -- -- Run two picklers in sequence like with xpSeq. When during unpickling -- the first one fails, an alternative pickler (first argument) is -- applied. This pickler is only used as combinator for unpickling. xpChoice :: PU b -> PU a -> (a -> PU b) -> PU b -- | map value into another domain and apply pickler there -- -- One of the most often used picklers. xpWrap :: (a -> b, b -> a) -> PU a -> PU b -- | like xpWrap, but if the inverse mapping is undefined, the -- unpickler fails -- -- Map a value into another domain. If the inverse mapping is undefined -- (Nothing), the unpickler fails xpWrapMaybe :: (a -> Maybe b, b -> a) -> PU a -> PU b -- | pickle a pair of values sequentially -- -- Used for pairs or together with wrap for pickling algebraic data types -- with two components xpPair :: PU a -> PU b -> PU (a, b) -- | Like xpPair but for triples xpTriple :: PU a -> PU b -> PU c -> PU (a, b, c) -- | Like xpPair and xpTriple but for 4-tuples xp4Tuple :: PU a -> PU b -> PU c -> PU d -> PU (a, b, c, d) -- | Like xpPair and xpTriple but for 5-tuples xp5Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU (a, b, c, d, e) -- | Like xpPair and xpTriple but for 6-tuples xp6Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU (a, b, c, d, e, f) -- | Like xpPair and xpTriple but for 7-tuples -- -- Thanks to Tony Morris for doing xp7Tuple, ..., xp24Tuple. xp7Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU (a, b, c, d, e, f, g) xp8Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU (a, b, c, d, e, f, g, h) xp9Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU (a, b, c, d, e, f, g, h, i) xp10Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU (a, b, c, d, e, f, g, h, i, j) xp11Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU (a, b, c, d, e, f, g, h, i, j, k) xp12Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU (a, b, c, d, e, f, g, h, i, j, k, l) xp13Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m) xp14Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n) xp15Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) xp16Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) xp17Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) xp18Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) xp19Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) xp20Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) xp21Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) xp22Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) xp23Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -- | Hopefully no one needs a xp25Tuple xp24Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU x -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -- | Pickle a string into an XML text node -- -- One of the most often used primitive picklers. Attention: For pickling -- empty strings use xpText0. If the text has a more specific -- datatype than xsd:string, use xpTextDT xpText :: PU String -- | Pickle a string into an XML text node -- -- Text pickler with a description of the structure of the text by a -- schema. A schema for a data type can be defined by scDT. In -- Text.XML.HXT.Arrow.Pickle.Schema there are some more -- functions for creating simple datatype descriptions. xpTextDT :: Schema -> PU String -- | Pickle a possibly empty string into an XML node. -- -- Must be used in all places, where empty strings are legal values. If -- the content of an element can be an empty string, this string -- disapears during storing the DOM into a document and reparse the -- document. So the empty text node becomes nothing, and the pickler must -- deliver an empty string, if there is no text node in the document. xpText0 :: PU String -- | Pickle a possibly empty string with a datatype description into an XML -- node. -- -- Like xpText0 but with extra Parameter for datatype description -- as in xpTextDT. xpText0DT :: Schema -> PU String -- | Pickle an arbitrary value by applyling show during pickling and read -- during unpickling. -- -- Real pickling is then done with xpText. One of the most often -- used pimitive picklers. Applicable for all types which are instances -- of Read and Show xpPrim :: (Read a, Show a) => PU a -- | Pickle an XmlTree by just adding it -- -- Usefull for components of type XmlTree in other data structures xpTree :: PU XmlTree -- | Pickle a whole list of XmlTrees by just adding the list, unpickle is -- done by taking all element contents. -- -- This pickler should always be combined with xpElem for taking -- the whole contents of an element. xpTrees :: PU [XmlTree] -- | Pickle a string representing XML contents by inserting the tree -- representation into the XML document. -- -- Unpickling is done by converting the contents with -- xshowEscapeXml into a string, this function will escape all XML -- special chars, such that pickling the value back becomes save. -- Pickling is done with xread xpXmlText :: PU String -- | Encoding of optional data by ignoring the Nothing case during pickling -- and relying on failure during unpickling to recompute the Nothing case -- -- The default pickler for Maybe types xpOption :: PU a -> PU (Maybe a) -- | Optional conversion with default value -- -- The default value is not encoded in the XML document, during -- unpickling the default value is inserted if the pickler fails xpDefault :: Eq a => a -> PU a -> PU a -- | Encoding of list values by pickling all list elements sequentially. -- -- Unpickler relies on failure for detecting the end of the list. The -- standard pickler for lists. Can also be used in combination with -- xpWrap for constructing set and map picklers xpList :: PU a -> PU [a] -- | Encoding of a none empty list of values -- -- Attention: when calling this pickler with an empty list, an internal -- error "head of empty list is raised". xpList1 :: PU a -> PU [a] -- | Standard pickler for maps -- -- This pickler converts a map into a list of pairs. All key value pairs -- are mapped to an element with name (1.arg), the key is encoded as an -- attribute named by the 2. argument, the 3. arg is the pickler for the -- keys, the last one for the values xpMap :: Ord k => String -> String -> PU k -> PU v -> PU (Map k v) -- | Pickler for sum data types. -- -- Every constructor is mapped to an index into the list of picklers. The -- index is used only during pickling, not during unpickling, there the -- 1. match is taken xpAlt :: (a -> Int) -> [PU a] -> PU a -- | Pickler for wrapping/unwrapping data into an XML element -- -- Extra parameter is the element name given as a QName. THE pickler for -- constructing nested structures -- -- Example: -- -- 
--   xpElemQN (mkName "number") $ xpickle
--
-- -- will map an (42::Int) onto -- -- 
--   <number>42</number>
--
xpElemQN :: QName -> PU a -> PU a -- | convenient Pickler for xpElemQN -- -- 
--   xpElem n = xpElemQN (mkName n)
--
xpElem :: String -> PU a -> PU a -- | Pickler for wrapping/unwrapping data into an XML element with an -- attribute with given value -- -- To make XML structures flexible but limit the number of different -- elements, it's sometimes useful to use a kind of generic element with -- a key value structure -- -- Example: -- -- 
--   <attr name="key1">value1</attr>
--   <attr name="key2">value2</attr>
--   <attr name="key3">value3</attr>
--
-- -- the Haskell datatype may look like this -- -- 
--   type T = T { key1 :: Int ; key2 :: String ; key3 :: Double }
--
-- -- Then the picker for that type looks like this -- -- 
--   xpT :: PU T
--   xpT = xpWrap ( uncurry3 T, \ t -> (key1 t, key2 t, key3 t) ) $
--         xpTriple (xpElemWithAttrValue "attr" "name" "key1" $ xpickle)
--                  (xpElemWithAttrValue "attr" "name" "key2" $ xpText0)
--                  (xpElemWithAttrValue "attr" "name" "key3" $ xpickle)
--
xpElemWithAttrValue :: String -> String -> String -> PU a -> PU a -- | Pickler for storing/retreiving data into/from an attribute value -- -- The attribute is inserted in the surrounding element constructed by -- the xpElem pickler xpAttrQN :: QName -> PU a -> PU a -- | convenient Pickler for xpAttrQN -- -- 
--   xpAttr n = xpAttrQN (mkName n)
--
xpAttr :: String -> PU a -> PU a -- | A text attribute. xpTextAttr :: String -> PU String -- | Add an optional attribute for an optional value (Maybe a). xpAttrImplied :: String -> PU a -> PU (Maybe a) xpAttrFixed :: String -> String -> PU () -- | Add an attribute with a fixed value. -- -- Useful e.g. to declare namespaces. Is implemented by -- xpAttrFixed xpAddFixedAttr :: String -> String -> PU a -> PU a -- | The class for overloading xpickle, the default pickler class XmlPickler a xpickle :: XmlPickler a => PU a instance XmlPickler a => XmlPickler (Maybe a) instance XmlPickler a => XmlPickler [a] instance (XmlPickler a, XmlPickler b, XmlPickler c, XmlPickler d, XmlPickler e) => XmlPickler (a, b, c, d, e) instance (XmlPickler a, XmlPickler b, XmlPickler c, XmlPickler d) => XmlPickler (a, b, c, d) instance (XmlPickler a, XmlPickler b, XmlPickler c) => XmlPickler (a, b, c) instance (XmlPickler a, XmlPickler b) => XmlPickler (a, b) instance XmlPickler () instance XmlPickler Integer instance XmlPickler Int -- | Pickler functions for converting between user defined data types and -- XmlTree data. Usefull for persistent storage and retreival of arbitray -- data as XML documents -- -- This module is an adaptation of the pickler combinators developed by -- Andrew Kennedy ( -- http://research.microsoft.com/~akenn/fun/picklercombinators.pdf ) -- -- The difference to Kennedys approach is that the target is not a list -- of Chars but a list of XmlTrees. The basic picklers will convert data -- into XML text nodes. New are the picklers for creating elements and -- attributes. -- -- One extension was neccessary: The unpickling may fail. Therefore the -- unpickler has a Maybe result type. Failure is used to unpickle -- optional elements (Maybe data) and lists of arbitray length -- -- There is an example program demonstrating the use of the picklers for -- a none trivial data structure. (see "examples/arrows/pickle" -- directory) module Text.XML.HXT.Arrow.Pickle -- | store an arbitray value in a persistent XML document -- -- The pickler converts a value into an XML tree, this is written out -- with Text.XML.HXT.Arrow.writeDocument. The option list is -- passed to Text.XML.HXT.Arrow.writeDocument -- -- An option evaluated by this arrow is a_addDTD. If -- a_addDTD is set (v_1), the pickler DTD is added as an -- inline DTD into the document. xpickleDocument :: PU a -> SysConfigList -> String -> IOStateArrow s a XmlTree -- | read an arbitray value from an XML document -- -- The document is read with Text.XML.HXT.Arrow.readDocument. -- Options are passed to Text.XML.HXT.Arrow.readDocument. The -- conversion from XmlTree is done with the pickler. -- -- xpickleDocument xp al dest >>> xunpickleDocument xp al' -- dest is the identity arrow when applied with the appropriate -- options. When during pickling indentation is switched on, the -- whitespace must be removed during unpickling. xunpickleDocument :: PU a -> SysConfigList -> String -> IOStateArrow s b a -- | Write out the DTD generated out of a pickler. Calls -- xpicklerDTD xpickleWriteDTD :: PU b -> SysConfigList -> String -> IOStateArrow s b XmlTree -- | The arrow for generating the DTD out of a pickler -- -- A DTD is generated from a pickler and check for consistency. Errors -- concerning the DTD are issued. xpickleDTD :: PU b -> IOStateArrow s b XmlTree -- | An arrow for checking picklers -- -- A value is transformed into an XML document by a given pickler, the -- associated DTD is extracted from the pickler and checked, the document -- including the DTD is tranlated into a string, this string is read and -- validated against the included DTD, and unpickled. The last step is -- the equality with the input. -- -- If the check succeeds, the arrow works like this, else it fails. checkPickler :: Eq a => PU a -> IOStateArrow s a a -- | The arrow version of the pickler function xpickleVal :: ArrowXml a => PU b -> a b XmlTree -- | The arrow version of the unpickler function xunpickleVal :: ArrowXml a => PU b -> a XmlTree b -- | Compute the associated DTD of a pickler thePicklerDTD :: PU b -> XmlTrees -- | Option for generating and adding DTD when document is pickled a_addDTD :: String -- | conversion of an arbitrary value into an XML document tree. -- -- The pickler, first parameter, controls the conversion process. Result -- is a complete document tree including a root node pickleDoc :: PU a -> a -> XmlTree -- | Conversion of an XML document tree into an arbitrary data type -- -- The inverse of pickleDoc. This law should hold for all -- picklers: unpickle px . pickle px $ v == Just v . Not every -- possible combination of picklers make sense. For reconverting a value -- from an XML tree, is becomes neccessary, to introduce "enough" markup -- for unpickling the value unpickleDoc :: PU a -> XmlTree -> Maybe a -- | Pickles a value, then writes the document to a string. showPickled :: XmlPickler a => SysConfigList -> a -> String data PU a PU :: ((a, St) -> St) -> (St -> (Maybe a, St)) -> Schema -> PU a appPickle :: PU a -> (a, St) -> St appUnPickle :: PU a -> St -> (Maybe a, St) theSchema :: PU a -> Schema -- | The class for overloading xpickle, the default pickler class XmlPickler a xpickle :: XmlPickler a => PU a -- | Like xpPair and xpTriple but for 4-tuples xp4Tuple :: PU a -> PU b -> PU c -> PU d -> PU (a, b, c, d) -- | Like xpPair and xpTriple but for 5-tuples xp5Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU (a, b, c, d, e) -- | Like xpPair and xpTriple but for 6-tuples xp6Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU (a, b, c, d, e, f) -- | Like xpPair and xpTriple but for 7-tuples -- -- Thanks to Tony Morris for doing xp7Tuple, ..., xp24Tuple. xp7Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU (a, b, c, d, e, f, g) xp8Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU (a, b, c, d, e, f, g, h) xp9Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU (a, b, c, d, e, f, g, h, i) xp10Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU (a, b, c, d, e, f, g, h, i, j) xp11Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU (a, b, c, d, e, f, g, h, i, j, k) xp12Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU (a, b, c, d, e, f, g, h, i, j, k, l) xp13Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m) xp14Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n) xp15Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) xp16Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) xp17Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) xp18Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) xp19Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) xp20Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) xp21Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) xp22Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) xp23Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -- | Hopefully no one needs a xp25Tuple xp24Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU x -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -- | Add an attribute with a fixed value. -- -- Useful e.g. to declare namespaces. Is implemented by -- xpAttrFixed xpAddFixedAttr :: String -> String -> PU a -> PU a -- | Pickler for sum data types. -- -- Every constructor is mapped to an index into the list of picklers. The -- index is used only during pickling, not during unpickling, there the -- 1. match is taken xpAlt :: (a -> Int) -> [PU a] -> PU a -- | convenient Pickler for xpAttrQN -- -- 
--   xpAttr n = xpAttrQN (mkName n)
--
xpAttr :: String -> PU a -> PU a -- | A text attribute. xpTextAttr :: String -> PU String xpAttrFixed :: String -> String -> PU () -- | Add an optional attribute for an optional value (Maybe a). xpAttrImplied :: String -> PU a -> PU (Maybe a) -- | combine tow picklers with a choice -- -- Run two picklers in sequence like with xpSeq. When during unpickling -- the first one fails, an alternative pickler (first argument) is -- applied. This pickler is only used as combinator for unpickling. xpChoice :: PU b -> PU a -> (a -> PU b) -> PU b -- | pickle/unpickle combinator for sequence and choice. -- -- When the first unpickler fails, the second one is taken, else the -- third one configured with the result from the first is taken. This -- pickler is a generalisation for xpSeq and xpChoice . -- -- The schema must be attached later, e.g. in xpPair or other higher -- level combinators xpCondSeq :: PU b -> (b -> a) -> PU a -> (a -> PU b) -> PU b -- | Optional conversion with default value -- -- The default value is not encoded in the XML document, during -- unpickling the default value is inserted if the pickler fails xpDefault :: Eq a => a -> PU a -> PU a -- | convenient Pickler for xpElemQN -- -- 
--   xpElem n = xpElemQN (mkName n)
--
xpElem :: String -> PU a -> PU a -- | Pickler for wrapping/unwrapping data into an XML element with an -- attribute with given value -- -- To make XML structures flexible but limit the number of different -- elements, it's sometimes useful to use a kind of generic element with -- a key value structure -- -- Example: -- -- 
--   <attr name="key1">value1</attr>
--   <attr name="key2">value2</attr>
--   <attr name="key3">value3</attr>
--
-- -- the Haskell datatype may look like this -- -- 
--   type T = T { key1 :: Int ; key2 :: String ; key3 :: Double }
--
-- -- Then the picker for that type looks like this -- -- 
--   xpT :: PU T
--   xpT = xpWrap ( uncurry3 T, \ t -> (key1 t, key2 t, key3 t) ) $
--         xpTriple (xpElemWithAttrValue "attr" "name" "key1" $ xpickle)
--                  (xpElemWithAttrValue "attr" "name" "key2" $ xpText0)
--                  (xpElemWithAttrValue "attr" "name" "key3" $ xpickle)
--
xpElemWithAttrValue :: String -> String -> String -> PU a -> PU a -- | Lift a value to a pickler -- -- When pickling, nothing is encoded, when unpickling, the given value is -- inserted. This pickler always succeeds. xpLift :: a -> PU a -- | Lift a Maybe value to a pickler. -- -- Nothing is mapped to the zero pickler, Just x is -- pickled with xpLift x. xpLiftMaybe :: Maybe a -> PU a -- | Encoding of list values by pickling all list elements sequentially. -- -- Unpickler relies on failure for detecting the end of the list. The -- standard pickler for lists. Can also be used in combination with -- xpWrap for constructing set and map picklers xpList :: PU a -> PU [a] -- | Encoding of a none empty list of values -- -- Attention: when calling this pickler with an empty list, an internal -- error "head of empty list is raised". xpList1 :: PU a -> PU [a] -- | Standard pickler for maps -- -- This pickler converts a map into a list of pairs. All key value pairs -- are mapped to an element with name (1.arg), the key is encoded as an -- attribute named by the 2. argument, the 3. arg is the pickler for the -- keys, the last one for the values xpMap :: Ord k => String -> String -> PU k -> PU v -> PU (Map k v) -- | Encoding of optional data by ignoring the Nothing case during pickling -- and relying on failure during unpickling to recompute the Nothing case -- -- The default pickler for Maybe types xpOption :: PU a -> PU (Maybe a) -- | pickle a pair of values sequentially -- -- Used for pairs or together with wrap for pickling algebraic data types -- with two components xpPair :: PU a -> PU b -> PU (a, b) -- | Pickle an arbitrary value by applyling show during pickling and read -- during unpickling. -- -- Real pickling is then done with xpText. One of the most often -- used pimitive picklers. Applicable for all types which are instances -- of Read and Show xpPrim :: (Read a, Show a) => PU a -- | Combine two picklers sequentially. -- -- If the first fails during unpickling, the whole unpickler fails xpSeq :: (b -> a) -> PU a -> (a -> PU b) -> PU b -- | Pickle a string into an XML text node -- -- One of the most often used primitive picklers. Attention: For pickling -- empty strings use xpText0. If the text has a more specific -- datatype than xsd:string, use xpTextDT xpText :: PU String -- | Pickle a possibly empty string into an XML node. -- -- Must be used in all places, where empty strings are legal values. If -- the content of an element can be an empty string, this string -- disapears during storing the DOM into a document and reparse the -- document. So the empty text node becomes nothing, and the pickler must -- deliver an empty string, if there is no text node in the document. xpText0 :: PU String -- | Pickle a string into an XML text node -- -- Text pickler with a description of the structure of the text by a -- schema. A schema for a data type can be defined by scDT. In -- Text.XML.HXT.Arrow.Pickle.Schema there are some more -- functions for creating simple datatype descriptions. xpTextDT :: Schema -> PU String -- | Pickle a possibly empty string with a datatype description into an XML -- node. -- -- Like xpText0 but with extra Parameter for datatype description -- as in xpTextDT. xpText0DT :: Schema -> PU String -- | Pickle an XmlTree by just adding it -- -- Usefull for components of type XmlTree in other data structures xpTree :: PU XmlTree -- | Pickle a whole list of XmlTrees by just adding the list, unpickle is -- done by taking all element contents. -- -- This pickler should always be combined with xpElem for taking -- the whole contents of an element. xpTrees :: PU [XmlTree] -- | Like xpPair but for triples xpTriple :: PU a -> PU b -> PU c -> PU (a, b, c) xpUnit :: PU () -- | map value into another domain and apply pickler there -- -- One of the most often used picklers. xpWrap :: (a -> b, b -> a) -> PU a -> PU b -- | like xpWrap, but if the inverse mapping is undefined, the -- unpickler fails -- -- Map a value into another domain. If the inverse mapping is undefined -- (Nothing), the unpickler fails xpWrapMaybe :: (a -> Maybe b, b -> a) -> PU a -> PU b -- | Pickle a string representing XML contents by inserting the tree -- representation into the XML document. -- -- Unpickling is done by converting the contents with -- xshowEscapeXml into a string, this function will escape all XML -- special chars, such that pickling the value back becomes save. -- Pickling is done with xread xpXmlText :: PU String -- | The zero pickler -- -- Encodes nothing, fails always during unpickling xpZero :: PU a -- | The datatype for modelling the structure of an data Schema type Schemas = [Schema] data DataTypeDescr -- | Regular Expression Matcher working on lists of XmlTrees -- -- It's intendet to import this module with an explicit import -- declaration for not spoiling the namespace with these somewhat special -- arrows module Text.XML.HXT.Arrow.XmlRegex data XmlRegex mkZero :: String -> XmlRegex mkUnit :: XmlRegex mkPrim :: (XmlTree -> Bool) -> XmlRegex mkPrimA :: LA XmlTree XmlTree -> XmlRegex mkDot :: XmlRegex mkStar :: XmlRegex -> XmlRegex mkAlt :: XmlRegex -> XmlRegex -> XmlRegex mkAlts :: [XmlRegex] -> XmlRegex mkSeq :: XmlRegex -> XmlRegex -> XmlRegex mkSeqs :: [XmlRegex] -> XmlRegex mkRep :: Int -> XmlRegex -> XmlRegex mkRng :: Int -> Int -> XmlRegex -> XmlRegex mkOpt :: XmlRegex -> XmlRegex nullable :: XmlRegex -> Bool delta :: XmlRegex -> XmlTree -> XmlRegex -- | match a sequence of XML trees with a regular expression over trees -- -- If the input matches, the result is Nothing, else Just an error -- message is returned matchXmlRegex :: XmlRegex -> XmlTrees -> Maybe String -- | split a sequence of XML trees into a pair of a a matching prefix and a -- rest -- -- If there is no matching prefix, Nothing is returned splitXmlRegex :: XmlRegex -> XmlTrees -> Maybe (XmlTrees, XmlTrees) -- | scan a sequence of XML trees and split it into parts matching the -- given regex -- -- If the parts cannot be split because of a missing match, or because of -- the empty sequence as match, Nothing is returned scanXmlRegex :: XmlRegex -> XmlTrees -> Maybe [XmlTrees] -- | check whether a sequence of XmlTrees match an Xml regular expression -- -- The arrow for matchXmlRegex. -- -- The expession is build up from simple arrows acting as predicate -- (mkPrimA) for an XmlTree and of the usual cobinators for -- sequence (mkSeq), repetition (mkStar, mkRep', -- mkRng) and choice (mkAlt, mkOpt) matchRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree XmlTrees -- | split the sequence of trees computed by the filter a into -- -- The arrow for splitXmlRegex. -- -- a first part matching the regex and a rest, if a prefix of the input -- sequence does not match the regex, the arrow fails else the pair -- containing the result lists is returned splitRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree (XmlTrees, XmlTrees) -- | scan the input sequence with a regex and give the result as a list of -- lists of trees back the regex must at least match one input tree, so -- the empty sequence should not match the regex -- -- The arrow for scanXmlRegex. scanRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree XmlTrees instance Show XmlRegex -- | De-/Serialisation arrows for XmlTrees and other arbitrary values with -- a Binary instance module Text.XML.HXT.Arrow.Binary readBinaryValue :: (NFData a, Binary a) => String -> IOStateArrow s b a -- | Serialize a value, optionally compress it, and write it to a file. In -- case of an error, the error message is issued and the arrow fails writeBinaryValue :: Binary a => String -> IOStateArrow s a () -- | The HXT arrow interface -- -- The application programming interface to the arrow modules of the -- Haskell XML Toolbox. This module exports all important arrows for -- input, output, parsing, validating and transforming XML. It also -- exports all basic datatypes and functions of the toolbox. module Text.XML.HXT.Core