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
/= :: I4 -> I4 -> Bool
$c/= :: I4 -> I4 -> Bool
== :: I4 -> I4 -> Bool
$c== :: 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
showList :: [I4] -> ShowS
$cshowList :: [I4] -> ShowS
show :: I4 -> String
$cshow :: I4 -> String
showsPrec :: Int -> I4 -> ShowS
$cshowsPrec :: Int -> 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
/= :: I8 -> I8 -> Bool
$c/= :: I8 -> I8 -> Bool
== :: I8 -> I8 -> Bool
$c== :: 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
showList :: [I8] -> ShowS
$cshowList :: [I8] -> ShowS
show :: I8 -> String
$cshow :: I8 -> String
showsPrec :: Int -> I8 -> ShowS
$cshowsPrec :: Int -> 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
/= :: AInt -> AInt -> Bool
$c/= :: AInt -> AInt -> Bool
== :: AInt -> AInt -> Bool
$c== :: 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
showList :: [AInt] -> ShowS
$cshowList :: [AInt] -> ShowS
show :: AInt -> String
$cshow :: AInt -> String
showsPrec :: Int -> AInt -> ShowS
$cshowsPrec :: Int -> 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
/= :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c== :: 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
showList :: [Boolean] -> ShowS
$cshowList :: [Boolean] -> ShowS
show :: Boolean -> String
$cshow :: Boolean -> String
showsPrec :: Int -> Boolean -> ShowS
$cshowsPrec :: Int -> 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
/= :: AString -> AString -> Bool
$c/= :: AString -> AString -> Bool
== :: AString -> AString -> Bool
$c== :: 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
showList :: [AString] -> ShowS
$cshowList :: [AString] -> ShowS
show :: AString -> String
$cshow :: AString -> String
showsPrec :: Int -> AString -> ShowS
$cshowsPrec :: Int -> 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
/= :: ADouble -> ADouble -> Bool
$c/= :: ADouble -> ADouble -> Bool
== :: ADouble -> ADouble -> Bool
$c== :: 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
showList :: [ADouble] -> ShowS
$cshowList :: [ADouble] -> ShowS
show :: ADouble -> String
$cshow :: ADouble -> String
showsPrec :: Int -> ADouble -> ShowS
$cshowsPrec :: Int -> 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
/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
$c/= :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
== :: DateTime_iso8601 -> DateTime_iso8601 -> Bool
$c== :: 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
showList :: [DateTime_iso8601] -> ShowS
$cshowList :: [DateTime_iso8601] -> ShowS
show :: DateTime_iso8601 -> String
$cshow :: DateTime_iso8601 -> String
showsPrec :: Int -> DateTime_iso8601 -> ShowS
$cshowsPrec :: Int -> 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
/= :: Base64 -> Base64 -> Bool
$c/= :: Base64 -> Base64 -> Bool
== :: Base64 -> Base64 -> Bool
$c== :: 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
showList :: [Base64] -> ShowS
$cshowList :: [Base64] -> ShowS
show :: Base64 -> String
$cshow :: Base64 -> String
showsPrec :: Int -> Base64 -> ShowS
$cshowsPrec :: Int -> 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
/= :: Data -> Data -> Bool
$c/= :: Data -> Data -> Bool
== :: Data -> Data -> Bool
$c== :: 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
showList :: [Data] -> ShowS
$cshowList :: [Data] -> ShowS
show :: Data -> String
$cshow :: Data -> String
showsPrec :: Int -> Data -> ShowS
$cshowsPrec :: Int -> 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
/= :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c== :: 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
showList :: [Array] -> ShowS
$cshowList :: [Array] -> ShowS
show :: Array -> String
$cshow :: Array -> String
showsPrec :: Int -> Array -> ShowS
$cshowsPrec :: Int -> 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
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: 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
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> 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
/= :: Member -> Member -> Bool
$c/= :: Member -> Member -> Bool
== :: Member -> Member -> Bool
$c== :: 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
showList :: [Member] -> ShowS
$cshowList :: [Member] -> ShowS
show :: Member -> String
$cshow :: Member -> String
showsPrec :: Int -> Member -> ShowS
$cshowsPrec :: Int -> 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
/= :: Struct -> Struct -> Bool
$c/= :: Struct -> Struct -> Bool
== :: Struct -> Struct -> Bool
$c== :: 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
showList :: [Struct] -> ShowS
$cshowList :: [Struct] -> ShowS
show :: Struct -> String
$cshow :: Struct -> String
showsPrec :: Int -> Struct -> ShowS
$cshowsPrec :: Int -> 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
/= :: Nil -> Nil -> Bool
$c/= :: Nil -> Nil -> Bool
== :: Nil -> Nil -> Bool
$c== :: 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
showList :: [Nil] -> ShowS
$cshowList :: [Nil] -> ShowS
show :: Nil -> String
$cshow :: Nil -> String
showsPrec :: Int -> Nil -> ShowS
$cshowsPrec :: Int -> 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
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: 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
showList :: [Value] -> ShowS
$cshowList :: [Value] -> ShowS
show :: Value -> String
$cshow :: Value -> String
showsPrec :: Int -> Value -> ShowS
$cshowsPrec :: Int -> 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
/= :: Value_ -> Value_ -> Bool
$c/= :: Value_ -> Value_ -> Bool
== :: Value_ -> Value_ -> Bool
$c== :: 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
showList :: [Value_] -> ShowS
$cshowList :: [Value_] -> ShowS
show :: Value_ -> String
$cshow :: Value_ -> String
showsPrec :: Int -> Value_ -> ShowS
$cshowsPrec :: Int -> 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
/= :: Param -> Param -> Bool
$c/= :: Param -> Param -> Bool
== :: Param -> Param -> Bool
$c== :: 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
showList :: [Param] -> ShowS
$cshowList :: [Param] -> ShowS
show :: Param -> String
$cshow :: Param -> String
showsPrec :: Int -> Param -> ShowS
$cshowsPrec :: Int -> 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
/= :: Params -> Params -> Bool
$c/= :: Params -> Params -> Bool
== :: Params -> Params -> Bool
$c== :: 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
showList :: [Params] -> ShowS
$cshowList :: [Params] -> ShowS
show :: Params -> String
$cshow :: Params -> String
showsPrec :: Int -> Params -> ShowS
$cshowsPrec :: Int -> 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
/= :: MethodName -> MethodName -> Bool
$c/= :: MethodName -> MethodName -> Bool
== :: MethodName -> MethodName -> Bool
$c== :: 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
showList :: [MethodName] -> ShowS
$cshowList :: [MethodName] -> ShowS
show :: MethodName -> String
$cshow :: MethodName -> String
showsPrec :: Int -> MethodName -> ShowS
$cshowsPrec :: Int -> 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
/= :: MethodCall -> MethodCall -> Bool
$c/= :: MethodCall -> MethodCall -> Bool
== :: MethodCall -> MethodCall -> Bool
$c== :: 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
showList :: [MethodCall] -> ShowS
$cshowList :: [MethodCall] -> ShowS
show :: MethodCall -> String
$cshow :: MethodCall -> String
showsPrec :: Int -> MethodCall -> ShowS
$cshowsPrec :: Int -> 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
/= :: Fault -> Fault -> Bool
$c/= :: Fault -> Fault -> Bool
== :: Fault -> Fault -> Bool
$c== :: 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
showList :: [Fault] -> ShowS
$cshowList :: [Fault] -> ShowS
show :: Fault -> String
$cshow :: Fault -> String
showsPrec :: Int -> Fault -> ShowS
$cshowsPrec :: Int -> 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
/= :: MethodResponse -> MethodResponse -> Bool
$c/= :: MethodResponse -> MethodResponse -> Bool
== :: MethodResponse -> MethodResponse -> Bool
$c== :: 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
showList :: [MethodResponse] -> ShowS
$cshowList :: [MethodResponse] -> ShowS
show :: MethodResponse -> String
$cshow :: MethodResponse -> String
showsPrec :: Int -> MethodResponse -> ShowS
$cshowsPrec :: Int -> MethodResponse -> ShowS
Show)


{-Instance decls-}

instance HTypeable I4 where
    toHType :: I4 -> HType
toHType x :: I4
x = String -> [HType] -> [Constr] -> HType
Defined "i4" [] []
instance XmlContent I4 where
    toContents :: I4 -> [Content ()]
toContents (I4 a :: 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 "i4") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I4
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser I4 -> ShowS -> XMLParser I4
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <i4>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable I8 where
    toHType :: I8 -> HType
toHType x :: I8
x = String -> [HType] -> [Constr] -> HType
Defined "i8" [] []
instance XmlContent I8 where
    toContents :: I8 -> [Content ()]
toContents (I8 a :: 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 "i8") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser I8
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser I8 -> ShowS -> XMLParser I8
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <i8>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable AInt where
    toHType :: AInt -> HType
toHType x :: AInt
x = String -> [HType] -> [Constr] -> HType
Defined "int" [] []
instance XmlContent AInt where
    toContents :: AInt -> [Content ()]
toContents (AInt a :: 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 "int") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AInt
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser AInt -> ShowS -> XMLParser AInt
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <int>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Boolean where
    toHType :: Boolean -> HType
toHType x :: Boolean
x = String -> [HType] -> [Constr] -> HType
Defined "boolean" [] []
instance XmlContent Boolean where
    toContents :: Boolean -> [Content ()]
toContents (Boolean a :: 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 "boolean") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Boolean
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser Boolean -> ShowS -> XMLParser Boolean
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <boolean>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable AString where
    toHType :: AString -> HType
toHType x :: AString
x = String -> [HType] -> [Constr] -> HType
Defined "string" [] []
instance XmlContent AString where
    toContents :: AString -> [Content ()]
toContents (AString a :: 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 -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser AString
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser AString -> ShowS -> XMLParser AString
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <string>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable ADouble where
    toHType :: ADouble -> HType
toHType x :: ADouble
x = String -> [HType] -> [Constr] -> HType
Defined "double" [] []
instance XmlContent ADouble where
    toContents :: ADouble -> [Content ()]
toContents (ADouble a :: 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 "double") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser ADouble
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser ADouble -> ShowS -> XMLParser ADouble
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <double>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable DateTime_iso8601 where
    toHType :: DateTime_iso8601 -> HType
toHType x :: DateTime_iso8601
x = String -> [HType] -> [Constr] -> HType
Defined "dateTime.iso8601" [] []
instance XmlContent DateTime_iso8601 where
    toContents :: DateTime_iso8601 -> [Content ()]
toContents (DateTime_iso8601 a :: 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 "dateTime.iso8601") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser DateTime_iso8601
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser DateTime_iso8601 -> ShowS -> XMLParser DateTime_iso8601
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <dateTime.iso8601>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Nil where
    toHType :: Nil -> HType
toHType x :: Nil
x = String -> [HType] -> [Constr] -> HType
Defined "nil" [] []
instance XmlContent Nil where
    toContents :: Nil -> [Content ()]
toContents (Nil a :: ()
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 "nil") [] []) ()]
    parseContents :: XMLParser Nil
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return ())
        } XMLParser Nil -> ShowS -> XMLParser Nil
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <nil/>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Base64 where
    toHType :: Base64 -> HType
toHType x :: Base64
x = String -> [HType] -> [Constr] -> HType
Defined "base64" [] []
instance XmlContent Base64 where
    toContents :: Base64 -> [Content ()]
toContents (Base64 a :: 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 "base64") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Base64
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser Base64 -> ShowS -> XMLParser Base64
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <base64>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Data where
    toHType :: Data -> HType
toHType x :: Data
x = String -> [HType] -> [Constr] -> HType
Defined "data" [] []
instance XmlContent Data where
    toContents :: Data -> [Content ()]
toContents (Data a :: [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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <data>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Array where
    toHType :: Array -> HType
toHType x :: Array
x = String -> [HType] -> [Constr] -> HType
Defined "array" [] []
instance XmlContent Array where
    toContents :: Array -> [Content ()]
toContents (Array a :: 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 "array") [] (Data -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Data
a)) ()]
    parseContents :: XMLParser Array
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <array>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Name where
    toHType :: Name -> HType
toHType x :: Name
x = String -> [HType] -> [Constr] -> HType
Defined "name" [] []
instance XmlContent Name where
    toContents :: Name -> [Content ()]
toContents (Name a :: 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 "name") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser Name
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser Name -> ShowS -> XMLParser Name
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <name>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Member where
    toHType :: Member -> HType
toHType x :: Member
x = String -> [HType] -> [Constr] -> HType
Defined "member" [] []
instance XmlContent Member where
    toContents :: Member -> [Content ()]
toContents (Member a :: Name
a b :: 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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <member>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Struct where
    toHType :: Struct -> HType
toHType x :: Struct
x = String -> [HType] -> [Constr] -> HType
Defined "struct" [] []
instance XmlContent Struct where
    toContents :: Struct -> [Content ()]
toContents (Struct a :: [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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
many XMLParser Member
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Struct -> ShowS -> XMLParser Struct
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <struct>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value where
    toHType :: Value -> HType
toHType x :: Value
x = String -> [HType] -> [Constr] -> HType
Defined "value" [] []
instance XmlContent Value where
    toContents :: Value -> [Content ()]
toContents (Value a :: [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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <value>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Value_ where
    toHType :: Value_ -> HType
toHType x :: Value_
x = String -> [HType] -> [Constr] -> HType
Defined "value" [] []
instance XmlContent Value_ where
    toContents :: Value_ -> [Content ()]
toContents (Value_Str a :: String
a) = String -> [Content ()]
toText String
a
    toContents (Value_I4 a :: I4
a) = I4 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents I4
a
    toContents (Value_I8 a :: I8
a) = I8 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents I8
a
    toContents (Value_AInt a :: AInt
a) = AInt -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents AInt
a
    toContents (Value_Boolean a :: Boolean
a) = Boolean -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Boolean
a
    toContents (Value_AString a :: AString
a) = AString -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents AString
a
    toContents (Value_DateTime_iso8601 a :: DateTime_iso8601
a) = DateTime_iso8601 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents DateTime_iso8601
a
    toContents (Value_ADouble a :: ADouble
a) = ADouble -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents ADouble
a
    toContents (Value_Base64 a :: Base64
a) = Base64 -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Base64
a
    toContents (Value_Struct a :: Struct
a) = Struct -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Struct
a
    toContents (Value_Array a :: Array
a) = Array -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Array
a
    toContents (Value_Nil a :: 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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <value>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Param where
    toHType :: Param -> HType
toHType x :: Param
x = String -> [HType] -> [Constr] -> HType
Defined "param" [] []
instance XmlContent Param where
    toContents :: Param -> [Content ()]
toContents (Param a :: 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 "param") [] (Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Param
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <param>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Params where
    toHType :: Params -> HType
toHType x :: Params
x = String -> [HType] -> [Constr] -> HType
Defined "params" [] []
instance XmlContent Params where
    toContents :: Params -> [Content ()]
toContents (Params a :: [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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
many XMLParser Param
forall a. XmlContent a => XMLParser a
parseContents
        } XMLParser Params -> ShowS -> XMLParser Params
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <params>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodName where
    toHType :: MethodName -> HType
toHType x :: MethodName
x = String -> [HType] -> [Constr] -> HType
Defined "methodName" [] []
instance XmlContent MethodName where
    toContents :: MethodName -> [Content ()]
toContents (MethodName a :: 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 "methodName") [] (String -> [Content ()]
toText String
a)) ()]
    parseContents :: XMLParser MethodName
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (m :: * -> *) a. Monad m => a -> m a
return "")
        } XMLParser MethodName -> ShowS -> XMLParser MethodName
forall (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <methodName>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodCall where
    toHType :: MethodCall -> HType
toHType x :: MethodCall
x = String -> [HType] -> [Constr] -> HType
Defined "methodCall" [] []
instance XmlContent MethodCall where
    toContents :: MethodCall -> [Content ()]
toContents (MethodCall a :: MethodName
a b :: 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 "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 _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <methodCall>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable Fault where
    toHType :: Fault -> HType
toHType x :: Fault
x = String -> [HType] -> [Constr] -> HType
Defined "fault" [] []
instance XmlContent Fault where
    toContents :: Fault -> [Content ()]
toContents (Fault a :: 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 "fault") [] (Value -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Value
a)) ()]
    parseContents :: XMLParser Fault
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <fault>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance HTypeable MethodResponse where
    toHType :: MethodResponse -> HType
toHType x :: MethodResponse
x = String -> [HType] -> [Constr] -> HType
Defined "methodResponse" [] []
instance XmlContent MethodResponse where
    toContents :: MethodResponse -> [Content ()]
toContents (MethodResponseParams a :: 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 "methodResponse") [] (Params -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Params
a) ) ()]
    toContents (MethodResponseFault a :: 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 "methodResponse") [] (Fault -> [Content ()]
forall a. XmlContent a => a -> [Content ()]
toContents Fault
a) ) ()]
    parseContents :: XMLParser MethodResponse
parseContents = do
        { e :: Element Posn
e@(Elem _ [] _) <- [String] -> XMLParser (Element Posn)
element ["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 (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 (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 (p :: * -> *) a. Commitment p => p a -> ShowS -> p a
`adjustErr` ("in <methodResponse>, "String -> ShowS
forall a. [a] -> [a] -> [a]
++)
        }



{-Done-}