-------------------------------------------------------------------- -- | -- Module : Text.XML.Light.Proc -- Copyright : (c) Galois, Inc. 2007 -- License : BSD3 -- -- Maintainer: Iavor S. Diatchki <diatchki@galois.com> -- Stability : provisional -- Portability: -- -------------------------------------------------------------------- module Text.XML.Light.Proc where import Text.XML.Light.Types import Data.Maybe(listToMaybe) import Data.List(find) -- | Get the text value of an XML element. This function -- ignores non-text elements, and concatenates all text elements. strContent :: Element -> String strContent e = concatMap cdData $ onlyText $ elContent e -- | Select only the elements from a list of XML content. onlyElems :: [Content] -> [Element] onlyElems xs = [ x | Elem x <- xs ] -- | Select only the elements from a parent. elChildren :: Element -> [Element] elChildren e = [ x | Elem x <- elContent e ] -- | Select only the text from a list of XML content. onlyText :: [Content] -> [CData] onlyText xs = [ x | Text x <- xs ] -- | Find all immediate children with the given name. findChildren :: QName -> Element -> [Element] findChildren q e = filterChildren ((q ==) . elName) e -- | Filter all immediate children wrt a given predicate. filterChildren :: (Element -> Bool) -> Element -> [Element] filterChildren p e = filter p (onlyElems (elContent e)) -- | Filter all immediate children wrt a given predicate over their names. filterChildrenName :: (QName -> Bool) -> Element -> [Element] filterChildrenName p e = filter (p.elName) (onlyElems (elContent e)) -- | Find an immediate child with the given name. findChild :: QName -> Element -> Maybe Element findChild q e = listToMaybe (findChildren q e) -- | Find an immediate child with the given name. filterChild :: (Element -> Bool) -> Element -> Maybe Element filterChild p e = listToMaybe (filterChildren p e) -- | Find an immediate child with name matching a predicate. filterChildName :: (QName -> Bool) -> Element -> Maybe Element filterChildName p e = listToMaybe (filterChildrenName p e) -- | Find the left-most occurrence of an element matching given name. findElement :: QName -> Element -> Maybe Element findElement q e = listToMaybe (findElements q e) -- | Filter the left-most occurrence of an element wrt. given predicate. filterElement :: (Element -> Bool) -> Element -> Maybe Element filterElement p e = listToMaybe (filterElements p e) -- | Filter the left-most occurrence of an element wrt. given predicate. filterElementName :: (QName -> Bool) -> Element -> Maybe Element filterElementName p e = listToMaybe (filterElementsName p e) -- | Find all non-nested occurances of an element. -- (i.e., once we have found an element, we do not search -- for more occurances among the element's children). findElements :: QName -> Element -> [Element] findElements qn e = filterElementsName (qn==) e -- | Find all non-nested occurrences of an element wrt. given predicate. -- (i.e., once we have found an element, we do not search -- for more occurances among the element's children). filterElements :: (Element -> Bool) -> Element -> [Element] filterElements p e | p e = [e] | otherwise = concatMap (filterElements p) $ onlyElems $ elContent e -- | Find all non-nested occurences of an element wrt a predicate over element names. -- (i.e., once we have found an element, we do not search -- for more occurances among the element's children). filterElementsName :: (QName -> Bool) -> Element -> [Element] filterElementsName p e = filterElements (p.elName) e -- | Lookup the value of an attribute. findAttr :: QName -> Element -> Maybe String findAttr x e = lookupAttr x (elAttribs e) -- | Lookup attribute name from list. lookupAttr :: QName -> [Attr] -> Maybe String lookupAttr x = lookupAttrBy (x ==) -- | Lookup the first attribute whose name satisfies the given predicate. lookupAttrBy :: (QName -> Bool) -> [Attr] -> Maybe String lookupAttrBy p as = attrVal `fmap` find (p . attrKey) as -- | Lookup the value of the first attribute whose name -- satisfies the given predicate. findAttrBy :: (QName -> Bool) -> Element -> Maybe String findAttrBy p e = lookupAttrBy p (elAttribs e)