{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.XMLRPCParams
(
XMLRPCParams(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveXMLRPCParamsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
XMLRPCParamsFreeMethodInfo ,
#endif
xMLRPCParamsFree ,
#if defined(ENABLE_OVERLOADING)
XMLRPCParamsParseMethodInfo ,
#endif
xMLRPCParamsParse ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
newtype XMLRPCParams = XMLRPCParams (SP.ManagedPtr XMLRPCParams)
deriving (XMLRPCParams -> XMLRPCParams -> Bool
(XMLRPCParams -> XMLRPCParams -> Bool)
-> (XMLRPCParams -> XMLRPCParams -> Bool) -> Eq XMLRPCParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: XMLRPCParams -> XMLRPCParams -> Bool
$c/= :: XMLRPCParams -> XMLRPCParams -> Bool
== :: XMLRPCParams -> XMLRPCParams -> Bool
$c== :: XMLRPCParams -> XMLRPCParams -> Bool
Eq)
instance SP.ManagedPtrNewtype XMLRPCParams where
toManagedPtr :: XMLRPCParams -> ManagedPtr XMLRPCParams
toManagedPtr (XMLRPCParams ManagedPtr XMLRPCParams
p) = ManagedPtr XMLRPCParams
p
instance BoxedPtr XMLRPCParams where
boxedPtrCopy :: XMLRPCParams -> IO XMLRPCParams
boxedPtrCopy = XMLRPCParams -> IO XMLRPCParams
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: XMLRPCParams -> IO ()
boxedPtrFree = \XMLRPCParams
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList XMLRPCParams
type instance O.AttributeList XMLRPCParams = XMLRPCParamsAttributeList
type XMLRPCParamsAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "soup_xmlrpc_params_free" soup_xmlrpc_params_free ::
Ptr XMLRPCParams ->
IO ()
xMLRPCParamsFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
XMLRPCParams
-> m ()
xMLRPCParamsFree :: XMLRPCParams -> m ()
xMLRPCParamsFree XMLRPCParams
self = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr XMLRPCParams
self' <- XMLRPCParams -> IO (Ptr XMLRPCParams)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr XMLRPCParams
self
Ptr XMLRPCParams -> IO ()
soup_xmlrpc_params_free Ptr XMLRPCParams
self'
XMLRPCParams -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr XMLRPCParams
self
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data XMLRPCParamsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo XMLRPCParamsFreeMethodInfo XMLRPCParams signature where
overloadedMethod = xMLRPCParamsFree
#endif
foreign import ccall "soup_xmlrpc_params_parse" soup_xmlrpc_params_parse ::
Ptr XMLRPCParams ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
xMLRPCParamsParse ::
(B.CallStack.HasCallStack, MonadIO m) =>
XMLRPCParams
-> Maybe (T.Text)
-> m GVariant
xMLRPCParamsParse :: XMLRPCParams -> Maybe Text -> m GVariant
xMLRPCParamsParse XMLRPCParams
self Maybe Text
signature = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
Ptr XMLRPCParams
self' <- XMLRPCParams -> IO (Ptr XMLRPCParams)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr XMLRPCParams
self
Ptr CChar
maybeSignature <- case Maybe Text
signature of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jSignature -> do
Ptr CChar
jSignature' <- Text -> IO (Ptr CChar)
textToCString Text
jSignature
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jSignature'
IO GVariant -> IO () -> IO GVariant
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant))
-> (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a b. (a -> b) -> a -> b
$ Ptr XMLRPCParams
-> Ptr CChar -> Ptr (Ptr GError) -> IO (Ptr GVariant)
soup_xmlrpc_params_parse Ptr XMLRPCParams
self' Ptr CChar
maybeSignature
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xMLRPCParamsParse" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
XMLRPCParams -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr XMLRPCParams
self
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSignature
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
) (do
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSignature
)
#if defined(ENABLE_OVERLOADING)
data XMLRPCParamsParseMethodInfo
instance (signature ~ (Maybe (T.Text) -> m GVariant), MonadIO m) => O.MethodInfo XMLRPCParamsParseMethodInfo XMLRPCParams signature where
overloadedMethod = xMLRPCParamsParse
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveXMLRPCParamsMethod (t :: Symbol) (o :: *) :: * where
ResolveXMLRPCParamsMethod "free" o = XMLRPCParamsFreeMethodInfo
ResolveXMLRPCParamsMethod "parse" o = XMLRPCParamsParseMethodInfo
ResolveXMLRPCParamsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveXMLRPCParamsMethod t XMLRPCParams, O.MethodInfo info XMLRPCParams p) => OL.IsLabel t (XMLRPCParams -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif