module Network.XmlRpc.DTD_XMLRPC where

import           Text.XML.HaXml.OneOfN
import           Text.XML.HaXml.Types      (QName (..))
import           Text.XML.HaXml.XmlContent


{-Type decls-}

newtype I4 = I4 String          deriving (I4 -> I4 -> Bool
(I4 -> I4 -> Bool) -> (I4 -> I4 -> Bool) -> Eq I4
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: I4 -> I4 -> Bool
== :: I4 -> I4 -> Bool
$c/= :: I4 -> I4 -> Bool
/= :: I4 -> I4 -> Bool
Eq,Int -> I4 -> ShowS
[I4] -> ShowS
I4 -> String
(Int -> I4 -> ShowS)
-> (I4 -> String) -> ([I4] -> ShowS) -> Show I4
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> I4 -> ShowS
showsPrec :: Int -> I4 -> ShowS
$cshow :: I4 -> String
show :: I4 -> String
$cshowList :: [I4] -> ShowS
showList :: [I4] -> ShowS
Show)
newtype I8 = I8 String          deriving (I8 -> I8 -> Bool
(I8 -> I8 -> Bool) -> (I8 -> I8 -> Bool) -> Eq I8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: I8 -> I8 -> Bool
== :: I8 -> I8 -> Bool
$c/= :: I8 -> I8 -> Bool
/= :: I8 -> I8 -> Bool
Eq,Int -> I8 -> ShowS
[I8] -> ShowS
I8 -> String
(Int -> I8 -> ShowS)
-> (I8 -> String) -> ([I8] -> ShowS) -> Show I8
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> I8 -> ShowS
showsPrec :: Int -> I8 -> ShowS
$cshow :: I8 -> String
show :: I8 -> String
$cshowList :: [I8] -> ShowS
showList :: [I8] -> ShowS
Show)
newtype AInt = AInt String              deriving (AInt -> AInt -> Bool
(AInt -> AInt -> Bool) -> (AInt -> AInt -> Bool) -> Eq AInt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AInt -> AInt -> Bool
== :: AInt -> AInt -> Bool
$c/= :: AInt -> AInt -> Bool
/= :: AInt -> AInt -> Bool
Eq,Int -> AInt -> ShowS
[AInt] -> ShowS
AInt -> String
(Int -> AInt -> ShowS)
-> (AInt -> String) -> ([AInt] -> ShowS) -> Show AInt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AInt -> ShowS
showsPrec :: Int -> AInt -> ShowS
$cshow :: AInt -> String
show :: AInt -> String
$cshowList :: [AInt] -> ShowS
showList :: [AInt] -> ShowS
Show)
newtype Boolean = Boolean String                deriving (Boolean -> Boolean -> Bool
(Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool) -> Eq Boolean
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
/= :: Boolean -> Boolean -> Bool
Eq,Int -> Boolean -> ShowS
[Boolean] -> ShowS
Boolean -> String
(Int -> Boolean -> ShowS)
-> (Boolean -> String) -> ([Boolean] -> ShowS) -> Show Boolean
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Boolean -> ShowS
showsPrec :: Int -> Boolean -> ShowS
$cshow :: Boolean -> String
show :: Boolean -> String
$cshowList :: [Boolean] -> ShowS
showList :: [Boolean] -> ShowS
Show)
newtype AString = AString String                deriving (AString -> AString -> Bool
(AString -> AString -> Bool)
-> (AString -> AString -> Bool) -> Eq AString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AString -> AString -> Bool
== :: AString -> AString -> Bool
$c/= :: AString -> AString -> Bool
/= :: AString -> AString -> Bool
Eq,Int -> AString -> ShowS
[AString] -> ShowS
AString -> String
(Int -> AString -> ShowS)
-> (AString -> String) -> ([AString] -> ShowS) -> Show AString
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AString -> ShowS
showsPrec :: Int -> AString -> ShowS
$cshow :: AString -> String
show :: AString -> String
$cshowList :: [AString] -> ShowS
showList :: [AString] -> ShowS
Show)
newtype ADouble = ADouble String                deriving (ADouble -> ADouble -> Bool
(ADouble -> ADouble -> Bool)
-> (ADouble -> ADouble -> Bool) -> Eq ADouble
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ADouble -> ADouble -> Bool
== :: ADouble -> ADouble -> Bool
$c/= :: ADouble -> ADouble -> Bool
/= :: ADouble -> ADouble -> Bool
Eq,Int -> ADouble -> ShowS
[ADouble] -> ShowS
ADouble -> String
(Int -> ADouble -> ShowS)
-> (ADouble -> String) -> ([ADouble] -> ShowS) -> Show ADouble
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ADouble -> ShowS
showsPrec :: Int -> ADouble -> ShowS
$cshow :: ADouble -> String
show :: ADouble -> String
$cshowList :: [ADouble] -> ShowS
showList :: [ADouble] -> ShowS
Show)
newtype DateTime_iso8601 = DateTime_iso8601 String              deriving (DateTime_iso8601 -> DateTime_iso8601 -> Bool
(DateTime_iso8601 -> DateTime_iso8601 -> Bool)
-> (DateTime_iso8601 -> DateTime_iso8601 -> Bool)
-> Eq DateTime_iso8601
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
$c/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
Eq,Int -> DateTime_iso8601 -> ShowS
[DateTime_iso8601] -> ShowS
DateTime_iso8601 -> String
(Int -> DateTime_iso8601 -> ShowS)
-> (DateTime_iso8601 -> String)
-> ([DateTime_iso8601] -> ShowS)
-> Show DateTime_iso8601
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateTime_iso8601 -> ShowS
showsPrec :: Int -> DateTime_iso8601 -> ShowS
$cshow :: DateTime_iso8601 -> String
show :: DateTime_iso8601 -> String
$cshowList :: [DateTime_iso8601] -> ShowS
showList :: [DateTime_iso8601] -> ShowS
Show)
newtype Base64 = Base64 String          deriving (Base64 -> Base64 -> Bool
(Base64 -> Base64 -> Bool)
-> (Base64 -> Base64 -> Bool) -> Eq Base64
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Base64 -> Base64 -> Bool
== :: Base64 -> Base64 -> Bool
$c/= :: Base64 -> Base64 -> Bool
/= :: Base64 -> Base64 -> Bool
Eq,Int -> Base64 -> ShowS
[Base64] -> ShowS
Base64 -> String
(Int -> Base64 -> ShowS)
-> (Base64 -> String) -> ([Base64] -> ShowS) -> Show Base64
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Base64 -> ShowS
showsPrec :: Int -> Base64 -> ShowS
$cshow :: Base64 -> String
show :: Base64 -> String
$cshowList :: [Base64] -> ShowS
showList :: [Base64] -> ShowS
Show)
newtype Data = Data [Value]             deriving (Data -> Data -> Bool
(Data -> Data -> Bool) -> (Data -> Data -> Bool) -> Eq Data
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data -> Data -> Bool
== :: Data -> Data -> Bool
$c/= :: Data -> Data -> Bool
/= :: Data -> Data -> Bool
Eq,Int -> Data -> ShowS
[Data] -> ShowS
Data -> String
(Int -> Data -> ShowS)
-> (Data -> String) -> ([Data] -> ShowS) -> Show Data
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Data -> ShowS
showsPrec :: Int -> Data -> ShowS
$cshow :: Data -> String
show :: Data -> String
$cshowList :: [Data] -> ShowS
showList :: [Data] -> ShowS
Show)
newtype Array = Array Data              deriving (Array -> Array -> Bool
(Array -> Array -> Bool) -> (Array -> Array -> Bool) -> Eq Array
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
/= :: Array -> Array -> Bool
Eq,Int -> Array -> ShowS
[Array] -> ShowS
Array -> String
(Int -> Array -> ShowS)
-> (Array -> String) -> ([Array] -> ShowS) -> Show Array
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Array -> ShowS
showsPrec :: Int -> Array -> ShowS
$cshow :: Array -> String
show :: Array -> String
$cshowList :: [Array] -> ShowS
showList :: [Array] -> ShowS
Show)
newtype Name = Name String              deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
/= :: Name -> Name -> Bool
Eq,Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Name -> ShowS
showsPrec :: Int -> Name -> ShowS
$cshow :: Name -> String
show :: Name -> String
$cshowList :: [Name] -> ShowS
showList :: [Name] -> ShowS
Show)
data Member = Member Name Value
            deriving (Member -> Member -> Bool
(Member -> Member -> Bool)
-> (Member -> Member -> Bool) -> Eq Member
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Member -> Member -> Bool
== :: Member -> Member -> Bool
$c/= :: Member -> Member -> Bool
/= :: Member -> Member -> Bool
Eq,Int -> Member -> ShowS
[Member] -> ShowS
Member -> String
(Int -> Member -> ShowS)
-> (Member -> String) -> ([Member] -> ShowS) -> Show Member
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Member -> ShowS
showsPrec :: Int -> Member -> ShowS
$cshow :: Member -> String
show :: Member -> String
$cshowList :: [Member] -> ShowS
showList :: [Member] -> ShowS
Show)
newtype Struct = Struct [Member]                deriving (Struct -> Struct -> Bool
(Struct -> Struct -> Bool)
-> (Struct -> Struct -> Bool) -> Eq Struct
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Struct -> Struct -> Bool
== :: Struct -> Struct -> Bool
$c/= :: Struct -> Struct -> Bool
/= :: Struct -> Struct -> Bool
Eq,Int -> Struct -> ShowS
[Struct] -> ShowS
Struct -> String
(Int -> Struct -> ShowS)
-> (Struct -> String) -> ([Struct] -> ShowS) -> Show Struct
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Struct -> ShowS
showsPrec :: Int -> Struct -> ShowS
$cshow :: Struct -> String
show :: Struct -> String
$cshowList :: [Struct] -> ShowS
showList :: [Struct] -> ShowS
Show)
newtype Nil = Nil ()                    deriving (Nil -> Nil -> Bool
(Nil -> Nil -> Bool) -> (Nil -> Nil -> Bool) -> Eq Nil
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Nil -> Nil -> Bool
== :: Nil -> Nil -> Bool
$c/= :: Nil -> Nil -> Bool
/= :: Nil -> Nil -> Bool
Eq,Int -> Nil -> ShowS
[Nil] -> ShowS
Nil -> String
(Int -> Nil -> ShowS)
-> (Nil -> String) -> ([Nil] -> ShowS) -> Show Nil
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Nil -> ShowS
showsPrec :: Int -> Nil -> ShowS
$cshow :: Nil -> String
show :: Nil -> String
$cshowList :: [Nil] -> ShowS
showList :: [Nil] -> ShowS
Show)
newtype Value = Value [Value_]          deriving (Value -> Value -> Bool
(Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
/= :: Value -> Value -> Bool
Eq,Int -> Value -> ShowS
[Value] -> ShowS
Value -> String
(Int -> Value -> ShowS)
-> (Value -> String) -> ([Value] -> ShowS) -> Show Value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Value -> ShowS
showsPrec :: Int -> Value -> ShowS
$cshow :: Value -> String
show :: Value -> String
$cshowList :: [Value] -> ShowS
showList :: [Value] -> ShowS
Show)
data Value_ = Value_Str String
            | Value_I4 I4
            | Value_I8 I8
            | Value_AInt AInt
            | Value_Boolean Boolean
            | Value_AString AString
            | Value_DateTime_iso8601 DateTime_iso8601
            | Value_ADouble ADouble
            | Value_Base64 Base64
            | Value_Struct Struct
            | Value_Array Array
            | Value_Nil Nil
            deriving (Value_ -> Value_ -> Bool
(Value_ -> Value_ -> Bool)
-> (Value_ -> Value_ -> Bool) -> Eq Value_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Value_ -> Value_ -> Bool
== :: Value_ -> Value_ -> Bool
$c/= :: Value_ -> Value_ -> Bool
/= :: Value_ -> Value_ -> Bool
Eq,Int -> Value_ -> ShowS
[Value_] -> ShowS
Value_ -> String
(Int -> Value_ -> ShowS)
-> (Value_ -> String) -> ([Value_] -> ShowS) -> Show Value_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Value_ -> ShowS
showsPrec :: Int -> Value_ -> ShowS
$cshow :: Value_ -> String
show :: Value_ -> String
$cshowList :: [Value_] -> ShowS
showList :: [Value_] -> ShowS
Show)
newtype Param = Param Value             deriving (Param -> Param -> Bool
(Param -> Param -> Bool) -> (Param -> Param -> Bool) -> Eq Param
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Param -> Param -> Bool
== :: Param -> Param -> Bool
$c/= :: Param -> Param -> Bool
/= :: Param -> Param -> Bool
Eq,Int -> Param -> ShowS
[Param] -> ShowS
Param -> String
(Int -> Param -> ShowS)
-> (Param -> String) -> ([Param] -> ShowS) -> Show Param
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Param -> ShowS
showsPrec :: Int -> Param -> ShowS
$cshow :: Param -> String
show :: Param -> String
$cshowList :: [Param] -> ShowS
showList :: [Param] -> ShowS
Show)
newtype Params = Params [Param]                 deriving (Params -> Params -> Bool
(Params -> Params -> Bool)
-> (Params -> Params -> Bool) -> Eq Params
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Params -> Params -> Bool
== :: Params -> Params -> Bool
$c/= :: Params -> Params -> Bool
/= :: Params -> Params -> Bool
Eq,Int -> Params -> ShowS
[Params] -> ShowS
Params -> String
(Int -> Params -> ShowS)
-> (Params -> String) -> ([Params] -> ShowS) -> Show Params
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Params -> ShowS
showsPrec :: Int -> Params -> ShowS
$cshow :: Params -> String
show :: Params -> String
$cshowList :: [Params] -> ShowS
showList :: [Params] -> ShowS
Show)
newtype MethodName = MethodName String          deriving (MethodName -> MethodName -> Bool
(MethodName -> MethodName -> Bool)
-> (MethodName -> MethodName -> Bool) -> Eq MethodName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodName -> MethodName -> Bool
== :: MethodName -> MethodName -> Bool
$c/= :: MethodName -> MethodName -> Bool
/= :: MethodName -> MethodName -> Bool
Eq,Int -> MethodName -> ShowS
[MethodName] -> ShowS
MethodName -> String
(Int -> MethodName -> ShowS)
-> (MethodName -> String)
-> ([MethodName] -> ShowS)
-> Show MethodName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MethodName -> ShowS
showsPrec :: Int -> MethodName -> ShowS
$cshow :: MethodName -> String
show :: MethodName -> String
$cshowList :: [MethodName] -> ShowS
showList :: [MethodName] -> ShowS
Show)
data MethodCall = MethodCall MethodName (Maybe Params)
                deriving (MethodCall -> MethodCall -> Bool
(MethodCall -> MethodCall -> Bool)
-> (MethodCall -> MethodCall -> Bool) -> Eq MethodCall
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodCall -> MethodCall -> Bool
== :: MethodCall -> MethodCall -> Bool
$c/= :: MethodCall -> MethodCall -> Bool
/= :: MethodCall -> MethodCall -> Bool
Eq,Int -> MethodCall -> ShowS
[MethodCall] -> ShowS
MethodCall -> String
(Int -> MethodCall -> ShowS)
-> (MethodCall -> String)
-> ([MethodCall] -> ShowS)
-> Show MethodCall
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MethodCall -> ShowS
showsPrec :: Int -> MethodCall -> ShowS
$cshow :: MethodCall -> String
show :: MethodCall -> String
$cshowList :: [MethodCall] -> ShowS
showList :: [MethodCall] -> ShowS
Show)
newtype Fault = Fault Value             deriving (Fault -> Fault -> Bool
(Fault -> Fault -> Bool) -> (Fault -> Fault -> Bool) -> Eq Fault
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Fault -> Fault -> Bool
== :: Fault -> Fault -> Bool
$c/= :: Fault -> Fault -> Bool
/= :: Fault -> Fault -> Bool
Eq,Int -> Fault -> ShowS
[Fault] -> ShowS
Fault -> String
(Int -> Fault -> ShowS)
-> (Fault -> String) -> ([Fault] -> ShowS) -> Show Fault
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Fault -> ShowS
showsPrec :: Int -> Fault -> ShowS
$cshow :: Fault -> String
show :: Fault -> String
$cshowList :: [Fault] -> ShowS
showList :: [Fault] -> ShowS
Show)
data MethodResponse = MethodResponseParams Params
                    | MethodResponseFault Fault
                    deriving (MethodResponse -> MethodResponse -> Bool
(MethodResponse -> MethodResponse -> Bool)
-> (MethodResponse -> MethodResponse -> Bool) -> Eq MethodResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodResponse -> MethodResponse -> Bool
== :: MethodResponse -> MethodResponse -> Bool
$c/= :: MethodResponse -> MethodResponse -> Bool
/= :: MethodResponse -> MethodResponse -> Bool
Eq,Int -> MethodResponse -> ShowS
[MethodResponse] -> ShowS
MethodResponse -> String
(Int -> MethodResponse -> ShowS)
-> (MethodResponse -> String)
-> ([MethodResponse] -> ShowS)
-> Show MethodResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MethodResponse -> ShowS
showsPrec :: Int -> MethodResponse -> ShowS
$cshow :: MethodResponse -> String
show :: MethodResponse -> String
$cshowList :: [MethodResponse] -> ShowS
showList :: [MethodResponse] -> ShowS
Show)


{-Instance decls-}

instance HTypeable I4 where
    toHType :: I4 -> HType
toHType I4
x = String -> [HType] -> [Constr] -> HType
Defined String
"i4" [] []
instance XmlContent I4 where
    toContents :: I4 -> [Content ()]
toContents (I4 String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"i4") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I4
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"i4"]
        ; Element Posn -> XMLParser I4 -> XMLParser I4
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser I4 -> XMLParser I4) -> XMLParser I4 -> XMLParser I4
forall a b. (a -> b) -> a -> b
$ (String -> I4) -> Parser (Content Posn) (String -> I4)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> I4
I4) Parser (Content Posn) (String -> I4)
-> Parser (Content Posn) String -> XMLParser I4
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser I4 -> ShowS -> XMLParser I4
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <i4>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable I8 where
    toHType :: I8 -> HType
toHType I8
x = String -> [HType] -> [Constr] -> HType
Defined String
"i8" [] []
instance XmlContent I8 where
    toContents :: I8 -> [Content ()]
toContents (I8 String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"i8") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I8
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"i8"]
        ; Element Posn -> XMLParser I8 -> XMLParser I8
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser I8 -> XMLParser I8) -> XMLParser I8 -> XMLParser I8
forall a b. (a -> b) -> a -> b
$ (String -> I8) -> Parser (Content Posn) (String -> I8)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> I8
I8) Parser (Content Posn) (String -> I8)
-> Parser (Content Posn) String -> XMLParser I8
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser I8 -> ShowS -> XMLParser I8
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <i8>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable AInt where
    toHType :: AInt -> HType
toHType AInt
x = String -> [HType] -> [Constr] -> HType
Defined String
"int" [] []
instance XmlContent AInt where
    toContents :: AInt -> [Content ()]
toContents (AInt String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"int") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AInt
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"int"]
        ; Element Posn -> XMLParser AInt -> XMLParser AInt
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser AInt -> XMLParser AInt)
-> XMLParser AInt -> XMLParser AInt
forall a b. (a -> b) -> a -> b
$ (String -> AInt) -> Parser (Content Posn) (String -> AInt)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> AInt
AInt) Parser (Content Posn) (String -> AInt)
-> Parser (Content Posn) String -> XMLParser AInt
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser AInt -> ShowS -> XMLParser AInt
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <int>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Boolean where
    toHType :: Boolean -> HType
toHType Boolean
x = String -> [HType] -> [Constr] -> HType
Defined String
"boolean" [] []
instance XmlContent Boolean where
    toContents :: Boolean -> [Content ()]
toContents (Boolean String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"boolean") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Boolean
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"boolean"]
        ; Element Posn -> XMLParser Boolean -> XMLParser Boolean
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Boolean -> XMLParser Boolean)
-> XMLParser Boolean -> XMLParser Boolean
forall a b. (a -> b) -> a -> b
$ (String -> Boolean) -> Parser (Content Posn) (String -> Boolean)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Boolean
Boolean) Parser (Content Posn) (String -> Boolean)
-> Parser (Content Posn) String -> XMLParser Boolean
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser Boolean -> ShowS -> XMLParser Boolean
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <boolean>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable AString where
    toHType :: AString -> HType
toHType AString
x = String -> [HType] -> [Constr] -> HType
Defined String
"string" [] []
instance XmlContent AString where
    toContents :: AString -> [Content ()]
toContents (AString String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"string") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AString
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"string"]
        ; Element Posn -> XMLParser AString -> XMLParser AString
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser AString -> XMLParser AString)
-> XMLParser AString -> XMLParser AString
forall a b. (a -> b) -> a -> b
$ (String -> AString) -> Parser (Content Posn) (String -> AString)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> AString
AString) Parser (Content Posn) (String -> AString)
-> Parser (Content Posn) String -> XMLParser AString
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser AString -> ShowS -> XMLParser AString
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <string>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable ADouble where
    toHType :: ADouble -> HType
toHType ADouble
x = String -> [HType] -> [Constr] -> HType
Defined String
"double" [] []
instance XmlContent ADouble where
    toContents :: ADouble -> [Content ()]
toContents (ADouble String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"double") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser ADouble
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"double"]
        ; Element Posn -> XMLParser ADouble -> XMLParser ADouble
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser ADouble -> XMLParser ADouble)
-> XMLParser ADouble -> XMLParser ADouble
forall a b. (a -> b) -> a -> b
$ (String -> ADouble) -> Parser (Content Posn) (String -> ADouble)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ADouble
ADouble) Parser (Content Posn) (String -> ADouble)
-> Parser (Content Posn) String -> XMLParser ADouble
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser ADouble -> ShowS -> XMLParser ADouble
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <double>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable DateTime_iso8601 where
    toHType :: DateTime_iso8601 -> HType
toHType DateTime_iso8601
x = String -> [HType] -> [Constr] -> HType
Defined String
"dateTime.iso8601" [] []
instance XmlContent DateTime_iso8601 where
    toContents :: DateTime_iso8601 -> [Content ()]
toContents (DateTime_iso8601 String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"dateTime.iso8601") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser DateTime_iso8601
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"dateTime.iso8601"]
        ; Element Posn
-> XMLParser DateTime_iso8601 -> XMLParser DateTime_iso8601
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser DateTime_iso8601 -> XMLParser DateTime_iso8601)
-> XMLParser DateTime_iso8601 -> XMLParser DateTime_iso8601
forall a b. (a -> b) -> a -> b
$ (String -> DateTime_iso8601)
-> Parser (Content Posn) (String -> DateTime_iso8601)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> DateTime_iso8601
DateTime_iso8601)
                       Parser (Content Posn) (String -> DateTime_iso8601)
-> Parser (Content Posn) String -> XMLParser DateTime_iso8601
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser DateTime_iso8601 -> ShowS -> XMLParser DateTime_iso8601
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <dateTime.iso8601>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Nil where
    toHType :: Nil -> HType
toHType Nil
x = String -> [HType] -> [Constr] -> HType
Defined String
"nil" [] []
instance XmlContent Nil where
    toContents :: Nil -> [Content ()]
toContents (Nil ()
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"nil") [] []) ()]
    parseContents :: XMLParser Nil
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"nil"]
        ; Element Posn -> XMLParser Nil -> XMLParser Nil
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Nil -> XMLParser Nil) -> XMLParser Nil -> XMLParser Nil
forall a b. (a -> b) -> a -> b
$ (() -> Nil) -> Parser (Content Posn) (() -> Nil)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (() -> Nil
Nil) Parser (Content Posn) (() -> Nil)
-> Parser (Content Posn) () -> XMLParser Nil
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (() -> Parser (Content Posn) ()
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
        } XMLParser Nil -> ShowS -> XMLParser Nil
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <nil/>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Base64 where
    toHType :: Base64 -> HType
toHType Base64
x = String -> [HType] -> [Constr] -> HType
Defined String
"base64" [] []
instance XmlContent Base64 where
    toContents :: Base64 -> [Content ()]
toContents (Base64 String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"base64") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Base64
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"base64"]
        ; Element Posn -> XMLParser Base64 -> XMLParser Base64
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Base64 -> XMLParser Base64)
-> XMLParser Base64 -> XMLParser Base64
forall a b. (a -> b) -> a -> b
$ (String -> Base64) -> Parser (Content Posn) (String -> Base64)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Base64
Base64) Parser (Content Posn) (String -> Base64)
-> Parser (Content Posn) String -> XMLParser Base64
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser Base64 -> ShowS -> XMLParser Base64
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <base64>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Data where
    toHType :: Data -> HType
toHType Data
x = String -> [HType] -> [Constr] -> HType
Defined String
"data" [] []
instance XmlContent Data where
    toContents :: Data -> [Content ()]
toContents (Data [Value]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"data") [] ((Value -> [Content ()]) -> [Value] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Value]
a)) ()]
    parseContents :: XMLParser Data
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"data"]
        ; Element Posn -> XMLParser Data -> XMLParser Data
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Data -> XMLParser Data)
-> XMLParser Data -> XMLParser Data
forall a b. (a -> b) -> a -> b
$ ([Value] -> Data) -> Parser (Content Posn) ([Value] -> Data)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Value] -> Data
Data) Parser (Content Posn) ([Value] -> Data)
-> Parser (Content Posn) [Value] -> XMLParser Data
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Value -> Parser (Content Posn) [Value]
forall a. Parser (Content Posn) a -> Parser (Content Posn) [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Value
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Data -> ShowS -> XMLParser Data
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <data>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Array where
    toHType :: Array -> HType
toHType Array
x = String -> [HType] -> [Constr] -> HType
Defined String
"array" [] []
instance XmlContent Array where
    toContents :: Array -> [Content ()]
toContents (Array Data
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"array") [] (Data -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Data
a)) ()]
    parseContents :: XMLParser Array
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"array"]
        ; Element Posn -> XMLParser Array -> XMLParser Array
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Array -> XMLParser Array)
-> XMLParser Array -> XMLParser Array
forall a b. (a -> b) -> a -> b
$ (Data -> Array) -> Parser (Content Posn) (Data -> Array)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Data -> Array
Array) Parser (Content Posn) (Data -> Array)
-> XMLParser Data -> XMLParser Array
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Data
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Array -> ShowS -> XMLParser Array
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <array>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Name where
    toHType :: Name -> HType
toHType Name
x = String -> [HType] -> [Constr] -> HType
Defined String
"name" [] []
instance XmlContent Name where
    toContents :: Name -> [Content ()]
toContents (Name String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"name") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Name
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"name"]
        ; Element Posn -> XMLParser Name -> XMLParser Name
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Name -> XMLParser Name)
-> XMLParser Name -> XMLParser Name
forall a b. (a -> b) -> a -> b
$ (String -> Name) -> Parser (Content Posn) (String -> Name)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Name
Name) Parser (Content Posn) (String -> Name)
-> Parser (Content Posn) String -> XMLParser Name
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser Name -> ShowS -> XMLParser Name
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <name>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Member where
    toHType :: Member -> HType
toHType Member
x = String -> [HType] -> [Constr] -> HType
Defined String
"member" [] []
instance XmlContent Member where
    toContents :: Member -> [Content ()]
toContents (Member Name
a Value
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"member") [] (Name -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Name
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++ Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Value
b)) ()]
    parseContents :: XMLParser Member
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"member"]
        ; Element Posn -> XMLParser Member -> XMLParser Member
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Member -> XMLParser Member)
-> XMLParser Member -> XMLParser Member
forall a b. (a -> b) -> a -> b
$ (Name -> Value -> Member)
-> Parser (Content Posn) (Name -> Value -> Member)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Value -> Member
Member) Parser (Content Posn) (Name -> Value -> Member)
-> XMLParser Name -> Parser (Content Posn) (Value -> Member)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Name
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (Value -> Member)
-> Parser (Content Posn) Value -> XMLParser Member
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Value
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Member -> ShowS -> XMLParser Member
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <member>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Struct where
    toHType :: Struct -> HType
toHType Struct
x = String -> [HType] -> [Constr] -> HType
Defined String
"struct" [] []
instance XmlContent Struct where
    toContents :: Struct -> [Content ()]
toContents (Struct [Member]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"struct") [] ((Member -> [Content ()]) -> [Member] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Member -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Member]
a)) ()]
    parseContents :: XMLParser Struct
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"struct"]
        ; Element Posn -> XMLParser Struct -> XMLParser Struct
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Struct -> XMLParser Struct)
-> XMLParser Struct -> XMLParser Struct
forall a b. (a -> b) -> a -> b
$ ([Member] -> Struct) -> Parser (Content Posn) ([Member] -> Struct)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Member] -> Struct
Struct) Parser (Content Posn) ([Member] -> Struct)
-> Parser (Content Posn) [Member] -> XMLParser Struct
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Member -> Parser (Content Posn) [Member]
forall a. Parser (Content Posn) a -> Parser (Content Posn) [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many XMLParser Member
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Struct -> ShowS -> XMLParser Struct
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <struct>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value where
    toHType :: Value -> HType
toHType Value
x = String -> [HType] -> [Constr] -> HType
Defined String
"value" [] []
instance XmlContent Value where
    toContents :: Value -> [Content ()]
toContents (Value [Value_]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"value") [] ((Value_ -> [Content ()]) -> [Value_] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Value_ -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Value_]
a)) ()]
    parseContents :: Parser (Content Posn) Value
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"value"]
        ; Element Posn
-> Parser (Content Posn) Value -> Parser (Content Posn) Value
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (Parser (Content Posn) Value -> Parser (Content Posn) Value)
-> Parser (Content Posn) Value -> Parser (Content Posn) Value
forall a b. (a -> b) -> a -> b
$ ([Value_] -> Value) -> Parser (Content Posn) ([Value_] -> Value)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Value_] -> Value
Value) Parser (Content Posn) ([Value_] -> Value)
-> Parser (Content Posn) [Value_] -> Parser (Content Posn) Value
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Value_ -> Parser (Content Posn) [Value_]
forall a. Parser (Content Posn) a -> Parser (Content Posn) [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Content Posn) Value_
forall a. XmlContent a => XMLParser a
parseContents
        } Parser (Content Posn) Value -> ShowS -> Parser (Content Posn) Value
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <value>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value_ where
    toHType :: Value_ -> HType
toHType Value_
x = String -> [HType] -> [Constr] -> HType
Defined String
"value" [] []
instance XmlContent Value_ where
    toContents :: Value_ -> [Content ()]
toContents (Value_Str String
a) = String -> [Content ()]
toText String
a
    toContents (Value_I4 I4
a) = I4 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents I4
a
    toContents (Value_I8 I8
a) = I8 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents I8
a
    toContents (Value_AInt AInt
a) = AInt -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents AInt
a
    toContents (Value_Boolean Boolean
a) = Boolean -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Boolean
a
    toContents (Value_AString AString
a) = AString -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents AString
a
    toContents (Value_DateTime_iso8601 DateTime_iso8601
a) = DateTime_iso8601 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents DateTime_iso8601
a
    toContents (Value_ADouble ADouble
a) = ADouble -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents ADouble
a
    toContents (Value_Base64 Base64
a) = Base64 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Base64
a
    toContents (Value_Struct Struct
a) = Struct -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Struct
a
    toContents (Value_Array Array
a) = Array -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Array
a
    toContents (Value_Nil Nil
a) = Nil -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Nil
a
    parseContents :: Parser (Content Posn) Value_
parseContents = [Parser (Content Posn) Value_] -> Parser (Content Posn) Value_
forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
        [ (String -> Value_) -> Parser (Content Posn) (String -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Value_
Value_Str) Parser (Content Posn) (String -> Value_)
-> Parser (Content Posn) String -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) String
text
        , (I4 -> Value_) -> Parser (Content Posn) (I4 -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (I4 -> Value_
Value_I4) Parser (Content Posn) (I4 -> Value_)
-> XMLParser I4 -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser I4
forall a. XmlContent a => XMLParser a
parseContents
        , (I8 -> Value_) -> Parser (Content Posn) (I8 -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (I8 -> Value_
Value_I8) Parser (Content Posn) (I8 -> Value_)
-> XMLParser I8 -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser I8
forall a. XmlContent a => XMLParser a
parseContents
        , (AInt -> Value_) -> Parser (Content Posn) (AInt -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AInt -> Value_
Value_AInt) Parser (Content Posn) (AInt -> Value_)
-> XMLParser AInt -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser AInt
forall a. XmlContent a => XMLParser a
parseContents
        , (Boolean -> Value_) -> Parser (Content Posn) (Boolean -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Boolean -> Value_
Value_Boolean) Parser (Content Posn) (Boolean -> Value_)
-> XMLParser Boolean -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Boolean
forall a. XmlContent a => XMLParser a
parseContents
        , (AString -> Value_) -> Parser (Content Posn) (AString -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AString -> Value_
Value_AString) Parser (Content Posn) (AString -> Value_)
-> XMLParser AString -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser AString
forall a. XmlContent a => XMLParser a
parseContents
        , (DateTime_iso8601 -> Value_)
-> Parser (Content Posn) (DateTime_iso8601 -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DateTime_iso8601 -> Value_
Value_DateTime_iso8601) Parser (Content Posn) (DateTime_iso8601 -> Value_)
-> XMLParser DateTime_iso8601 -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser DateTime_iso8601
forall a. XmlContent a => XMLParser a
parseContents
        , (ADouble -> Value_) -> Parser (Content Posn) (ADouble -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ADouble -> Value_
Value_ADouble) Parser (Content Posn) (ADouble -> Value_)
-> XMLParser ADouble -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser ADouble
forall a. XmlContent a => XMLParser a
parseContents
        , (Base64 -> Value_) -> Parser (Content Posn) (Base64 -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Base64 -> Value_
Value_Base64) Parser (Content Posn) (Base64 -> Value_)
-> XMLParser Base64 -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Base64
forall a. XmlContent a => XMLParser a
parseContents
        , (Struct -> Value_) -> Parser (Content Posn) (Struct -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Struct -> Value_
Value_Struct) Parser (Content Posn) (Struct -> Value_)
-> XMLParser Struct -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Struct
forall a. XmlContent a => XMLParser a
parseContents
        , (Array -> Value_) -> Parser (Content Posn) (Array -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Array -> Value_
Value_Array) Parser (Content Posn) (Array -> Value_)
-> XMLParser Array -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Array
forall a. XmlContent a => XMLParser a
parseContents
        , (Nil -> Value_) -> Parser (Content Posn) (Nil -> Value_)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Nil -> Value_
Value_Nil) Parser (Content Posn) (Nil -> Value_)
-> XMLParser Nil -> Parser (Content Posn) Value_
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Nil
forall a. XmlContent a => XMLParser a
parseContents
        ] Parser (Content Posn) Value_
-> ShowS -> Parser (Content Posn) Value_
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <value>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Param where
    toHType :: Param -> HType
toHType Param
x = String -> [HType] -> [Constr] -> HType
Defined String
"param" [] []
instance XmlContent Param where
    toContents :: Param -> [Content ()]
toContents (Param Value
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"param") [] (Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Param
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"param"]
        ; Element Posn -> XMLParser Param -> XMLParser Param
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Param -> XMLParser Param)
-> XMLParser Param -> XMLParser Param
forall a b. (a -> b) -> a -> b
$ (Value -> Param) -> Parser (Content Posn) (Value -> Param)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value -> Param
Param) Parser (Content Posn) (Value -> Param)
-> Parser (Content Posn) Value -> XMLParser Param
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Value
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Param -> ShowS -> XMLParser Param
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <param>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Params where
    toHType :: Params -> HType
toHType Params
x = String -> [HType] -> [Constr] -> HType
Defined String
"params" [] []
instance XmlContent Params where
    toContents :: Params -> [Content ()]
toContents (Params [Param]
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"params") [] ((Param -> [Content ()]) -> [Param] -> [Content ()]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Param -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents [Param]
a)) ()]
    parseContents :: XMLParser Params
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"params"]
        ; Element Posn -> XMLParser Params -> XMLParser Params
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Params -> XMLParser Params)
-> XMLParser Params -> XMLParser Params
forall a b. (a -> b) -> a -> b
$ ([Param] -> Params) -> Parser (Content Posn) ([Param] -> Params)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Param] -> Params
Params) Parser (Content Posn) ([Param] -> Params)
-> Parser (Content Posn) [Param] -> XMLParser Params
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Param -> Parser (Content Posn) [Param]
forall a. Parser (Content Posn) a -> Parser (Content Posn) [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many XMLParser Param
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Params -> ShowS -> XMLParser Params
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <params>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodName where
    toHType :: MethodName -> HType
toHType MethodName
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodName" [] []
instance XmlContent MethodName where
    toContents :: MethodName -> [Content ()]
toContents (MethodName String
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodName") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser MethodName
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodName"]
        ; Element Posn -> XMLParser MethodName -> XMLParser MethodName
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser MethodName -> XMLParser MethodName)
-> XMLParser MethodName -> XMLParser MethodName
forall a b. (a -> b) -> a -> b
$ (String -> MethodName)
-> Parser (Content Posn) (String -> MethodName)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> MethodName
MethodName)
                       Parser (Content Posn) (String -> MethodName)
-> Parser (Content Posn) String -> XMLParser MethodName
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` (Parser (Content Posn) String
text Parser (Content Posn) String
-> Parser (Content Posn) String -> Parser (Content Posn) String
forall t a. Parser t a -> Parser t a -> Parser t a
`onFail` String -> Parser (Content Posn) String
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
        } XMLParser MethodName -> ShowS -> XMLParser MethodName
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodName>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodCall where
    toHType :: MethodCall -> HType
toHType MethodCall
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodCall" [] []
instance XmlContent MethodCall where
    toContents :: MethodCall -> [Content ()]
toContents (MethodCall MethodName
a Maybe Params
b) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodCall") [] (MethodName -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents MethodName
a [Content ()] -> [Content ()] -> [Content ()]
forall a. [a] -> [a] -> [a]
++
                                      [Content ()]
-> (Params -> [Content ()]) -> Maybe Params -> [Content ()]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] Params -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Maybe Params
b)) ()]
    parseContents :: XMLParser MethodCall
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodCall"]
        ; Element Posn -> XMLParser MethodCall -> XMLParser MethodCall
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser MethodCall -> XMLParser MethodCall)
-> XMLParser MethodCall -> XMLParser MethodCall
forall a b. (a -> b) -> a -> b
$ (MethodName -> Maybe Params -> MethodCall)
-> Parser (Content Posn) (MethodName -> Maybe Params -> MethodCall)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MethodName -> Maybe Params -> MethodCall
MethodCall) Parser (Content Posn) (MethodName -> Maybe Params -> MethodCall)
-> XMLParser MethodName
-> Parser (Content Posn) (Maybe Params -> MethodCall)
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser MethodName
forall a. XmlContent a => XMLParser a
parseContents
                       Parser (Content Posn) (Maybe Params -> MethodCall)
-> Parser (Content Posn) (Maybe Params) -> XMLParser MethodCall
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Params -> Parser (Content Posn) (Maybe Params)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional XMLParser Params
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser MethodCall -> ShowS -> XMLParser MethodCall
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodCall>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Fault where
    toHType :: Fault -> HType
toHType Fault
x = String -> [HType] -> [Constr] -> HType
Defined String
"fault" [] []
instance XmlContent Fault where
    toContents :: Fault -> [Content ()]
toContents (Fault Value
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"fault") [] (Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Fault
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"fault"]
        ; Element Posn -> XMLParser Fault -> XMLParser Fault
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser Fault -> XMLParser Fault)
-> XMLParser Fault -> XMLParser Fault
forall a b. (a -> b) -> a -> b
$ (Value -> Fault) -> Parser (Content Posn) (Value -> Fault)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value -> Fault
Fault) Parser (Content Posn) (Value -> Fault)
-> Parser (Content Posn) Value -> XMLParser Fault
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` Parser (Content Posn) Value
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Fault -> ShowS -> XMLParser Fault
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <fault>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodResponse where
    toHType :: MethodResponse -> HType
toHType MethodResponse
x = String -> [HType] -> [Constr] -> HType
Defined String
"methodResponse" [] []
instance XmlContent MethodResponse where
    toContents :: MethodResponse -> [Content ()]
toContents (MethodResponseParams Params
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodResponse") [] (Params -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Params
a) ) ()]
    toContents (MethodResponseFault Fault
a) =
        [Element () -> () -> Content ()
forall i. Element i -> i -> Content i
CElem (QName -> [Attribute] -> [Content ()] -> Element ()
forall i. QName -> [Attribute] -> [Content i] -> Element i
Elem (String -> QName
N String
"methodResponse") [] (Fault -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Fault
a) ) ()]
    parseContents :: XMLParser MethodResponse
parseContents = do
        { e :: Element Posn
e@(Elem QName
_ [] [Content Posn]
_) <- [String] -> XMLParser (Element Posn)
element [String
"methodResponse"]
        ; Element Posn
-> XMLParser MethodResponse -> XMLParser MethodResponse
forall a. Element Posn -> XMLParser a -> XMLParser a
interior Element Posn
e (XMLParser MethodResponse -> XMLParser MethodResponse)
-> XMLParser MethodResponse -> XMLParser MethodResponse
forall a b. (a -> b) -> a -> b
$ [XMLParser MethodResponse] -> XMLParser MethodResponse
forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf
            [ (Params -> MethodResponse)
-> Parser (Content Posn) (Params -> MethodResponse)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Params -> MethodResponse
MethodResponseParams) Parser (Content Posn) (Params -> MethodResponse)
-> XMLParser Params -> XMLParser MethodResponse
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Params
forall a. XmlContent a => XMLParser a
parseContents
            , (Fault -> MethodResponse)
-> Parser (Content Posn) (Fault -> MethodResponse)
forall a. a -> Parser (Content Posn) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Fault -> MethodResponse
MethodResponseFault) Parser (Content Posn) (Fault -> MethodResponse)
-> XMLParser Fault -> XMLParser MethodResponse
forall (p :: * -> *) a b. PolyParse p => p (a -> b) -> p a -> p b
`apply` XMLParser Fault
forall a. XmlContent a => XMLParser a
parseContents
            ] XMLParser MethodResponse -> ShowS -> XMLParser MethodResponse
forall a.
Parser (Content Posn) a -> ShowS -> Parser (Content Posn) a
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` (String
"in <methodResponse>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
        }



{-Done-}