module Text.XML.Basic.String where

import qualified Text.XML.Basic.Character as XMLChar
import qualified Text.XML.Basic.Entity as XMLEnt
import qualified Data.Map as Map
import qualified Data.Char as Char


-- | should be [Word8]
type Encoded  = String

{- |
Decode encoded characters and XML references.
Invalid references are silently skipped.
-}
decode ::
   (Encoded -> String) ->
   [XMLChar.T] ->
   String
decode :: (String -> String) -> [T] -> String
decode =
   Map String Char -> (String -> String) -> [T] -> String
decodeGen Map String Char
XMLEnt.mapNameToChar

decodeGen ::
   Map.Map XMLEnt.Name Char ->
   (Encoded -> String) ->
   [XMLChar.T] ->
   String
decodeGen :: Map String Char -> (String -> String) -> [T] -> String
decodeGen Map String Char
mapNameToChar String -> String
decoder =
   forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a b. (a -> b) -> a -> b
($) [] forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a.
(String -> a) -> (Int -> a) -> (String -> a) -> [T] -> [a]
XMLChar.switchUnicodeRuns
      (forall a. [a] -> [a] -> [a]
(++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
decoder)
      (\Int
n ->
         if Int -> Bool
XMLChar.validCharRef Int
n
           then (Int -> Char
Char.chr Int
n forall a. a -> [a] -> [a]
:)
           else forall a. a -> a
id)
      (\String
n ->
         forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. a -> a
id (:) forall a b. (a -> b) -> a -> b
$
         forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
n Map String Char
mapNameToChar)


{-
type Reference = Either Int String

data T = Cons String Reference R
data R = R Reference R | S T
-}