module Text.XML.WraXML.String.HaXml where

import Text.XML.HaXml(AttValue(AttValue), Reference, )
import qualified Text.XML.HaXml as HaXml

import qualified Text.XML.WraXML.String  as XmlString
import qualified Text.XML.Basic.Character as XmlChar

import Data.Maybe.HT (alternatives, (?->), )


toXmlString :: AttValue -> XmlString.T
toXmlString :: AttValue -> T
toXmlString (AttValue [Either String Reference]
s) =
   forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> T
XmlString.fromString ((forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reference -> Atom
refToXmlAtom)) [Either String Reference]
s

fromXmlString :: XmlString.T -> AttValue
fromXmlString :: T -> AttValue
fromXmlString =
   [Either String Reference] -> AttValue
AttValue forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a. (String -> a) -> (Int -> a) -> (String -> a) -> T -> [a]
XmlChar.switchUnicodeRuns
      forall a b. a -> Either a b
Left
      (forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Reference
HaXml.RefChar)
      (forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Reference
HaXml.RefEntity)

lift :: (XmlString.T -> XmlString.T) -> (AttValue -> AttValue)
lift :: (T -> T) -> AttValue -> AttValue
lift T -> T
f = T -> AttValue
fromXmlString forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> T
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttValue -> T
toXmlString

refToXmlAtom :: HaXml.Reference -> XmlString.Atom
refToXmlAtom :: Reference -> Atom
refToXmlAtom Reference
ref =
   case Reference
ref of
      HaXml.RefChar   Int
num  -> Int -> Atom
XmlChar.fromCharRef   Int
num
      HaXml.RefEntity String
name -> String -> Atom
XmlChar.fromEntityRef String
name

charFromXmlAtom' :: XmlChar.T -> Either Char Reference
charFromXmlAtom' :: Atom -> Either Char Reference
charFromXmlAtom' Atom
c =
   case Atom
c of
      XmlChar.Unicode   Char
char -> forall a b. a -> Either a b
Left Char
char
      XmlChar.EntityRef String
name -> forall a b. b -> Either a b
Right (String -> Reference
HaXml.RefEntity String
name)
      XmlChar.CharRef   Int
num  -> forall a b. b -> Either a b
Right (Int -> Reference
HaXml.RefChar   Int
num)

charFromXmlAtom :: XmlChar.T -> Either Char Reference
charFromXmlAtom :: Atom -> Either Char Reference
charFromXmlAtom Atom
c =
   forall a. a -> [Maybe a] -> a
alternatives
      (forall a. HasCallStack => String -> a
error String
"HaXml.charFromXmlAtom: unsupported constructor in XmlChar.T") forall a b. (a -> b) -> a -> b
$
      Atom -> Maybe Char
XmlChar.maybeUnicode   Atom
c forall a b. Maybe a -> (a -> b) -> Maybe b
?-> forall a b. a -> Either a b
Left forall a. a -> [a] -> [a]
:
      Atom -> Maybe String
XmlChar.maybeEntityRef Atom
c forall a b. Maybe a -> (a -> b) -> Maybe b
?-> forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Reference
HaXml.RefEntity forall a. a -> [a] -> [a]
:
      Atom -> Maybe Int
XmlChar.maybeCharRef   Atom
c forall a b. Maybe a -> (a -> b) -> Maybe b
?-> forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Reference
HaXml.RefChar forall a. a -> [a] -> [a]
:
      []