{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.XMLRPCParams
(
XMLRPCParams(..) ,
noXMLRPCParams ,
#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.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 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 (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 WrappedPtr XMLRPCParams where
wrappedPtrCalloc :: IO (Ptr XMLRPCParams)
wrappedPtrCalloc = Ptr XMLRPCParams -> IO (Ptr XMLRPCParams)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr XMLRPCParams
forall a. Ptr a
nullPtr
wrappedPtrCopy :: XMLRPCParams -> IO XMLRPCParams
wrappedPtrCopy = XMLRPCParams -> IO XMLRPCParams
forall (m :: * -> *) a. Monad m => a -> m a
return
wrappedPtrFree :: Maybe (GDestroyNotify XMLRPCParams)
wrappedPtrFree = Maybe (GDestroyNotify XMLRPCParams)
forall a. Maybe a
Nothing
noXMLRPCParams :: Maybe XMLRPCParams
noXMLRPCParams :: Maybe XMLRPCParams
noXMLRPCParams = Maybe XMLRPCParams
forall a. Maybe a
Nothing
#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 self :: 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 self :: XMLRPCParams
self signature :: 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
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jSignature :: 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 "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