hxt-9.3.1.16: A collection of tools for processing XML with Haskell.

CopyrightCopyright (C) 2011 Uwe Schmidt
LicenseMIT
MaintainerUwe Schmidt (uwe@fh-wedel.de)
Stabilitystable
Portabilityportable
Safe HaskellNone
LanguageHaskell98

Text.XML.HXT.DOM.QualifiedName

Description

The types and functions for qualified names

Synopsis

Documentation

data QName #

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 propagateNamespaces to split names of structure "prefix:localPart" and label the name with the apropriate namespace uri

Instances

Eq QName #

Two QNames are equal if (1. case) namespaces are both empty and the qualified names (prefix:localpart) are the same or (2. case) namespaces are set and namespaces and local parts are equal

Methods

(==) :: QName -> QName -> Bool #

(/=) :: QName -> QName -> Bool #

Ord QName # 

Methods

compare :: QName -> QName -> Ordering #

(<) :: QName -> QName -> Bool #

(<=) :: QName -> QName -> Bool #

(>) :: QName -> QName -> Bool #

(>=) :: QName -> QName -> Bool #

max :: QName -> QName -> QName #

min :: QName -> QName -> QName #

Show QName # 

Methods

showsPrec :: Int -> QName -> ShowS #

show :: QName -> String #

showList :: [QName] -> ShowS #

Binary QName # 

Methods

put :: QName -> Put #

get :: Get QName #

putList :: [QName] -> Put #

NFData QName # 

Methods

rnf :: QName -> () #

WNFData QName # 

Methods

rwnf :: QName -> () #

rwnf2 :: QName -> () #

data XName #

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

Instances

Eq XName # 

Methods

(==) :: XName -> XName -> Bool #

(/=) :: XName -> XName -> Bool #

Ord XName # 

Methods

compare :: XName -> XName -> Ordering #

(<) :: XName -> XName -> Bool #

(<=) :: XName -> XName -> Bool #

(>) :: XName -> XName -> Bool #

(>=) :: XName -> XName -> Bool #

max :: XName -> XName -> XName #

min :: XName -> XName -> XName #

Binary XName # 

Methods

put :: XName -> Put #

get :: Get XName #

putList :: [XName] -> Put #

NFData XName # 

Methods

rnf :: XName -> () #

WNFData XName # 

Methods

rwnf :: XName -> () #

rwnf2 :: XName -> () #

type NsEnv = AssocList XName XName #

Type for the namespace association list, used when propagating namespaces by modifying the QName values in a tree

mkQName :: String -> String -> String -> QName #

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.

mkName :: 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.

mkNsName :: String -> String -> QName #

constructs a simple, namespace aware name, with prefix:localPart as first parameter, namspace uri as second.

see also mkName, mkPrefixLocalPart

mkSNsName :: String -> QName #

Deprecated: use mkName instead

old name for mkName

mkPrefixLocalPart :: String -> String -> QName #

constructs a simple name, with prefix and localPart but without a namespace uri.

see also mkQName, mkName

equivQName :: QName -> QName -> Bool #

Equivalent QNames are defined as follows: The URIs are normalized before comparison. Comparison is done with equalQNameBy and equivUri

equivUri :: String -> String -> Bool #

Comparison of normalized namespace URIs using normalizeNsUri

equalQNameBy :: (String -> String -> Bool) -> QName -> QName -> 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

mkQName' :: XName -> XName -> XName -> QName #

Deprecated: use newQName instead with lp px ns param seq

setNamePrefix' :: XName -> QName -> QName #

set name prefix

setLocalPart' :: XName -> QName -> QName #

set local part

setNamespaceUri' :: XName -> QName -> QName #

set name prefix

qualifiedName :: QName -> String #

builds the full name "prefix:localPart", if prefix is not null, else the local part is the result

qualifiedName' :: QName -> String -> String #

functional list version of qualifiedName used in xshow

universalName :: QName -> String #

builds the "universal" name, that is the namespace uri surrounded with "{" and "}" followed by the local part (specialisation of buildUniversalName)

universalUri :: 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)

buildUniversalName :: (String -> String -> String) -> 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

normalizeNsUri :: String -> String #

Normalization of URIs: Normalization is done by conversion into lowercase letters. A trailing "/" is ignored

setNamespace :: NsEnv -> QName -> QName #

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.

isNCName :: String -> Bool #

test for wellformed NCName, rule [4] XML Namespaces

isWellformedQualifiedName :: String -> Bool #

test for wellformed QName, rule [6] XML Namespaces predicate is used in filter valdateNamespaces.

isWellformedQName :: QName -> 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.

isWellformedNSDecl :: 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.

isWellformedNameSpaceName :: QName -> Bool #

test for a namespace name to be well formed

isNameSpaceName :: QName -> Bool #

test whether a name is a namespace declaration attribute name

isDeclaredNamespace :: QName -> Bool #

predicate is used in filter valdateNamespaces.