{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.DBusMessage
(
DBusMessage(..) ,
IsDBusMessage ,
toDBusMessage ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusMessageMethod ,
#endif
dBusMessageBytesNeeded ,
#if defined(ENABLE_OVERLOADING)
DBusMessageCopyMethodInfo ,
#endif
dBusMessageCopy ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetArg0MethodInfo ,
#endif
dBusMessageGetArg0 ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetArg0PathMethodInfo ,
#endif
dBusMessageGetArg0Path ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetBodyMethodInfo ,
#endif
dBusMessageGetBody ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetByteOrderMethodInfo ,
#endif
dBusMessageGetByteOrder ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetDestinationMethodInfo ,
#endif
dBusMessageGetDestination ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetErrorNameMethodInfo ,
#endif
dBusMessageGetErrorName ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetFlagsMethodInfo ,
#endif
dBusMessageGetFlags ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetHeaderMethodInfo ,
#endif
dBusMessageGetHeader ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetHeaderFieldsMethodInfo ,
#endif
dBusMessageGetHeaderFields ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetInterfaceMethodInfo ,
#endif
dBusMessageGetInterface ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetLockedMethodInfo ,
#endif
dBusMessageGetLocked ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetMemberMethodInfo ,
#endif
dBusMessageGetMember ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetMessageTypeMethodInfo ,
#endif
dBusMessageGetMessageType ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetNumUnixFdsMethodInfo ,
#endif
dBusMessageGetNumUnixFds ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetPathMethodInfo ,
#endif
dBusMessageGetPath ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetReplySerialMethodInfo ,
#endif
dBusMessageGetReplySerial ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetSenderMethodInfo ,
#endif
dBusMessageGetSender ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetSerialMethodInfo ,
#endif
dBusMessageGetSerial ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetSignatureMethodInfo ,
#endif
dBusMessageGetSignature ,
#if defined(ENABLE_OVERLOADING)
DBusMessageGetUnixFdListMethodInfo ,
#endif
dBusMessageGetUnixFdList ,
#if defined(ENABLE_OVERLOADING)
DBusMessageLockMethodInfo ,
#endif
dBusMessageLock ,
dBusMessageNew ,
dBusMessageNewFromBlob ,
dBusMessageNewMethodCall ,
#if defined(ENABLE_OVERLOADING)
DBusMessageNewMethodErrorLiteralMethodInfo,
#endif
dBusMessageNewMethodErrorLiteral ,
#if defined(ENABLE_OVERLOADING)
DBusMessageNewMethodReplyMethodInfo ,
#endif
dBusMessageNewMethodReply ,
dBusMessageNewSignal ,
#if defined(ENABLE_OVERLOADING)
DBusMessagePrintMethodInfo ,
#endif
dBusMessagePrint ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetBodyMethodInfo ,
#endif
dBusMessageSetBody ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetByteOrderMethodInfo ,
#endif
dBusMessageSetByteOrder ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetDestinationMethodInfo ,
#endif
dBusMessageSetDestination ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetErrorNameMethodInfo ,
#endif
dBusMessageSetErrorName ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetFlagsMethodInfo ,
#endif
dBusMessageSetFlags ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetHeaderMethodInfo ,
#endif
dBusMessageSetHeader ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetInterfaceMethodInfo ,
#endif
dBusMessageSetInterface ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetMemberMethodInfo ,
#endif
dBusMessageSetMember ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetMessageTypeMethodInfo ,
#endif
dBusMessageSetMessageType ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetNumUnixFdsMethodInfo ,
#endif
dBusMessageSetNumUnixFds ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetPathMethodInfo ,
#endif
dBusMessageSetPath ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetReplySerialMethodInfo ,
#endif
dBusMessageSetReplySerial ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetSenderMethodInfo ,
#endif
dBusMessageSetSender ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetSerialMethodInfo ,
#endif
dBusMessageSetSerial ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetSignatureMethodInfo ,
#endif
dBusMessageSetSignature ,
#if defined(ENABLE_OVERLOADING)
DBusMessageSetUnixFdListMethodInfo ,
#endif
dBusMessageSetUnixFdList ,
#if defined(ENABLE_OVERLOADING)
DBusMessageToBlobMethodInfo ,
#endif
dBusMessageToBlob ,
#if defined(ENABLE_OVERLOADING)
DBusMessageToGerrorMethodInfo ,
#endif
dBusMessageToGerror ,
#if defined(ENABLE_OVERLOADING)
DBusMessageLockedPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
dBusMessageLocked ,
#endif
getDBusMessageLocked ,
) 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
#endif
newtype DBusMessage = DBusMessage (SP.ManagedPtr DBusMessage)
deriving (DBusMessage -> DBusMessage -> Bool
(DBusMessage -> DBusMessage -> Bool)
-> (DBusMessage -> DBusMessage -> Bool) -> Eq DBusMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DBusMessage -> DBusMessage -> Bool
== :: DBusMessage -> DBusMessage -> Bool
$c/= :: DBusMessage -> DBusMessage -> Bool
/= :: DBusMessage -> DBusMessage -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusMessage where
toManagedPtr :: DBusMessage -> ManagedPtr DBusMessage
toManagedPtr (DBusMessage ManagedPtr DBusMessage
p) = ManagedPtr DBusMessage
p
foreign import ccall "g_dbus_message_get_type"
c_g_dbus_message_get_type :: IO B.Types.GType
instance B.Types.TypedObject DBusMessage where
glibType :: IO GType
glibType = IO GType
c_g_dbus_message_get_type
instance B.Types.GObject DBusMessage
class (SP.GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o
instance (SP.GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o
instance O.HasParentTypes DBusMessage
type instance O.ParentTypes DBusMessage = '[GObject.Object.Object]
toDBusMessage :: (MIO.MonadIO m, IsDBusMessage o) => o -> m DBusMessage
toDBusMessage :: forall (m :: * -> *) o.
(MonadIO m, IsDBusMessage o) =>
o -> m DBusMessage
toDBusMessage = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DBusMessage -> m DBusMessage)
-> (o -> IO DBusMessage) -> o -> m DBusMessage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DBusMessage -> DBusMessage) -> o -> IO DBusMessage
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DBusMessage -> DBusMessage
DBusMessage
instance B.GValue.IsGValue (Maybe DBusMessage) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_message_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusMessage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusMessage
P.Nothing = Ptr GValue -> Ptr DBusMessage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DBusMessage
forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusMessage)
gvalueSet_ Ptr GValue
gv (P.Just DBusMessage
obj) = DBusMessage -> (Ptr DBusMessage -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusMessage
obj (Ptr GValue -> Ptr DBusMessage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusMessage)
gvalueGet_ Ptr GValue
gv = do
Ptr DBusMessage
ptr <- Ptr GValue -> IO (Ptr DBusMessage)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DBusMessage)
if Ptr DBusMessage
ptr Ptr DBusMessage -> Ptr DBusMessage -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DBusMessage
forall a. Ptr a
FP.nullPtr
then DBusMessage -> Maybe DBusMessage
forall a. a -> Maybe a
P.Just (DBusMessage -> Maybe DBusMessage)
-> IO DBusMessage -> IO (Maybe DBusMessage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage Ptr DBusMessage
ptr
else Maybe DBusMessage -> IO (Maybe DBusMessage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DBusMessage
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusMessageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDBusMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDBusMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDBusMessageMethod "copy" o = DBusMessageCopyMethodInfo
ResolveDBusMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDBusMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDBusMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDBusMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDBusMessageMethod "lock" o = DBusMessageLockMethodInfo
ResolveDBusMessageMethod "newMethodErrorLiteral" o = DBusMessageNewMethodErrorLiteralMethodInfo
ResolveDBusMessageMethod "newMethodReply" o = DBusMessageNewMethodReplyMethodInfo
ResolveDBusMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDBusMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDBusMessageMethod "print" o = DBusMessagePrintMethodInfo
ResolveDBusMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDBusMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDBusMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDBusMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDBusMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDBusMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDBusMessageMethod "toBlob" o = DBusMessageToBlobMethodInfo
ResolveDBusMessageMethod "toGerror" o = DBusMessageToGerrorMethodInfo
ResolveDBusMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDBusMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDBusMessageMethod "getArg0" o = DBusMessageGetArg0MethodInfo
ResolveDBusMessageMethod "getArg0Path" o = DBusMessageGetArg0PathMethodInfo
ResolveDBusMessageMethod "getBody" o = DBusMessageGetBodyMethodInfo
ResolveDBusMessageMethod "getByteOrder" o = DBusMessageGetByteOrderMethodInfo
ResolveDBusMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDBusMessageMethod "getDestination" o = DBusMessageGetDestinationMethodInfo
ResolveDBusMessageMethod "getErrorName" o = DBusMessageGetErrorNameMethodInfo
ResolveDBusMessageMethod "getFlags" o = DBusMessageGetFlagsMethodInfo
ResolveDBusMessageMethod "getHeader" o = DBusMessageGetHeaderMethodInfo
ResolveDBusMessageMethod "getHeaderFields" o = DBusMessageGetHeaderFieldsMethodInfo
ResolveDBusMessageMethod "getInterface" o = DBusMessageGetInterfaceMethodInfo
ResolveDBusMessageMethod "getLocked" o = DBusMessageGetLockedMethodInfo
ResolveDBusMessageMethod "getMember" o = DBusMessageGetMemberMethodInfo
ResolveDBusMessageMethod "getMessageType" o = DBusMessageGetMessageTypeMethodInfo
ResolveDBusMessageMethod "getNumUnixFds" o = DBusMessageGetNumUnixFdsMethodInfo
ResolveDBusMessageMethod "getPath" o = DBusMessageGetPathMethodInfo
ResolveDBusMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDBusMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDBusMessageMethod "getReplySerial" o = DBusMessageGetReplySerialMethodInfo
ResolveDBusMessageMethod "getSender" o = DBusMessageGetSenderMethodInfo
ResolveDBusMessageMethod "getSerial" o = DBusMessageGetSerialMethodInfo
ResolveDBusMessageMethod "getSignature" o = DBusMessageGetSignatureMethodInfo
ResolveDBusMessageMethod "getUnixFdList" o = DBusMessageGetUnixFdListMethodInfo
ResolveDBusMessageMethod "setBody" o = DBusMessageSetBodyMethodInfo
ResolveDBusMessageMethod "setByteOrder" o = DBusMessageSetByteOrderMethodInfo
ResolveDBusMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDBusMessageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDBusMessageMethod "setDestination" o = DBusMessageSetDestinationMethodInfo
ResolveDBusMessageMethod "setErrorName" o = DBusMessageSetErrorNameMethodInfo
ResolveDBusMessageMethod "setFlags" o = DBusMessageSetFlagsMethodInfo
ResolveDBusMessageMethod "setHeader" o = DBusMessageSetHeaderMethodInfo
ResolveDBusMessageMethod "setInterface" o = DBusMessageSetInterfaceMethodInfo
ResolveDBusMessageMethod "setMember" o = DBusMessageSetMemberMethodInfo
ResolveDBusMessageMethod "setMessageType" o = DBusMessageSetMessageTypeMethodInfo
ResolveDBusMessageMethod "setNumUnixFds" o = DBusMessageSetNumUnixFdsMethodInfo
ResolveDBusMessageMethod "setPath" o = DBusMessageSetPathMethodInfo
ResolveDBusMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDBusMessageMethod "setReplySerial" o = DBusMessageSetReplySerialMethodInfo
ResolveDBusMessageMethod "setSender" o = DBusMessageSetSenderMethodInfo
ResolveDBusMessageMethod "setSerial" o = DBusMessageSetSerialMethodInfo
ResolveDBusMessageMethod "setSignature" o = DBusMessageSetSignatureMethodInfo
ResolveDBusMessageMethod "setUnixFdList" o = DBusMessageSetUnixFdListMethodInfo
ResolveDBusMessageMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusMessageMethod t DBusMessage, O.OverloadedMethod info DBusMessage p) => OL.IsLabel t (DBusMessage -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDBusMessageMethod t DBusMessage, O.OverloadedMethod info DBusMessage p, R.HasField t DBusMessage p) => R.HasField t DBusMessage p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusMessageMethod t DBusMessage, O.OverloadedMethodInfo info DBusMessage) => OL.IsLabel t (O.MethodProxy info DBusMessage) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getDBusMessageLocked :: (MonadIO m, IsDBusMessage o) => o -> m Bool
getDBusMessageLocked :: forall (m :: * -> *) o. (MonadIO m, IsDBusMessage o) => o -> m Bool
getDBusMessageLocked o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"locked"
#if defined(ENABLE_OVERLOADING)
data DBusMessageLockedPropertyInfo
instance AttrInfo DBusMessageLockedPropertyInfo where
type AttrAllowedOps DBusMessageLockedPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint DBusMessageLockedPropertyInfo = IsDBusMessage
type AttrSetTypeConstraint DBusMessageLockedPropertyInfo = (~) ()
type AttrTransferTypeConstraint DBusMessageLockedPropertyInfo = (~) ()
type AttrTransferType DBusMessageLockedPropertyInfo = ()
type AttrGetType DBusMessageLockedPropertyInfo = Bool
type AttrLabel DBusMessageLockedPropertyInfo = "locked"
type AttrOrigin DBusMessageLockedPropertyInfo = DBusMessage
attrGet = getDBusMessageLocked
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.locked"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#g:attr:locked"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusMessage
type instance O.AttributeList DBusMessage = DBusMessageAttributeList
type DBusMessageAttributeList = ('[ '("locked", DBusMessageLockedPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
dBusMessageLocked :: AttrLabelProxy "locked"
dBusMessageLocked = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DBusMessage = DBusMessageSignalList
type DBusMessageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_dbus_message_new" g_dbus_message_new ::
IO (Ptr DBusMessage)
dBusMessageNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m DBusMessage
dBusMessageNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m DBusMessage
dBusMessageNew = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
result <- IO (Ptr DBusMessage)
g_dbus_message_new
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNew" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_dbus_message_new_from_blob" g_dbus_message_new_from_blob ::
Ptr Word8 ->
FCT.CSize ->
CUInt ->
Ptr (Ptr GError) ->
IO (Ptr DBusMessage)
dBusMessageNewFromBlob ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> [Gio.Flags.DBusCapabilityFlags]
-> m DBusMessage
dBusMessageNewFromBlob :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> [DBusCapabilityFlags] -> m DBusMessage
dBusMessageNewFromBlob ByteString
blob [DBusCapabilityFlags]
capabilities = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
let blobLen :: CSize
blobLen = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
blob
Ptr Word8
blob' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
blob
let capabilities' :: CUInt
capabilities' = [DBusCapabilityFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DBusCapabilityFlags]
capabilities
IO DBusMessage -> IO () -> IO DBusMessage
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DBusMessage
result <- (Ptr (Ptr GError) -> IO (Ptr DBusMessage)) -> IO (Ptr DBusMessage)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr DBusMessage))
-> IO (Ptr DBusMessage))
-> (Ptr (Ptr GError) -> IO (Ptr DBusMessage))
-> IO (Ptr DBusMessage)
forall a b. (a -> b) -> a -> b
$ Ptr Word8
-> CSize -> CUInt -> Ptr (Ptr GError) -> IO (Ptr DBusMessage)
g_dbus_message_new_from_blob Ptr Word8
blob' CSize
blobLen CUInt
capabilities'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNewFromBlob" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
blob'
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
) (do
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
blob'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_dbus_message_new_method_call" g_dbus_message_new_method_call ::
CString ->
CString ->
CString ->
CString ->
IO (Ptr DBusMessage)
dBusMessageNewMethodCall ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> T.Text
-> Maybe (T.Text)
-> T.Text
-> m DBusMessage
dBusMessageNewMethodCall :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> Text -> Maybe Text -> Text -> m DBusMessage
dBusMessageNewMethodCall Maybe Text
name Text
path Maybe Text
interface_ Text
method = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr CChar
path' <- Text -> IO (Ptr CChar)
textToCString Text
path
Ptr CChar
maybeInterface_ <- case Maybe Text
interface_ of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jInterface_ -> do
Ptr CChar
jInterface_' <- Text -> IO (Ptr CChar)
textToCString Text
jInterface_
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jInterface_'
Ptr CChar
method' <- Text -> IO (Ptr CChar)
textToCString Text
method
Ptr DBusMessage
result <- Ptr CChar
-> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO (Ptr DBusMessage)
g_dbus_message_new_method_call Ptr CChar
maybeName Ptr CChar
path' Ptr CChar
maybeInterface_ Ptr CChar
method'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNewMethodCall" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
path'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeInterface_
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
method'
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_dbus_message_new_signal" g_dbus_message_new_signal ::
CString ->
CString ->
CString ->
IO (Ptr DBusMessage)
dBusMessageNewSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> T.Text
-> m DBusMessage
dBusMessageNewSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> Text -> m DBusMessage
dBusMessageNewSignal Text
path Text
interface_ Text
signal = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
path' <- Text -> IO (Ptr CChar)
textToCString Text
path
Ptr CChar
interface_' <- Text -> IO (Ptr CChar)
textToCString Text
interface_
Ptr CChar
signal' <- Text -> IO (Ptr CChar)
textToCString Text
signal
Ptr DBusMessage
result <- Ptr CChar -> Ptr CChar -> Ptr CChar -> IO (Ptr DBusMessage)
g_dbus_message_new_signal Ptr CChar
path' Ptr CChar
interface_' Ptr CChar
signal'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNewSignal" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
path'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
interface_'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
signal'
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_dbus_message_copy" g_dbus_message_copy ::
Ptr DBusMessage ->
Ptr (Ptr GError) ->
IO (Ptr DBusMessage)
dBusMessageCopy ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m DBusMessage
dBusMessageCopy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m DBusMessage
dBusMessageCopy a
message = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
IO DBusMessage -> IO () -> IO DBusMessage
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DBusMessage
result <- (Ptr (Ptr GError) -> IO (Ptr DBusMessage)) -> IO (Ptr DBusMessage)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr DBusMessage))
-> IO (Ptr DBusMessage))
-> (Ptr (Ptr GError) -> IO (Ptr DBusMessage))
-> IO (Ptr DBusMessage)
forall a b. (a -> b) -> a -> b
$ Ptr DBusMessage -> Ptr (Ptr GError) -> IO (Ptr DBusMessage)
g_dbus_message_copy Ptr DBusMessage
message'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageCopy" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data DBusMessageCopyMethodInfo
instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageCopyMethodInfo a signature where
overloadedMethod = dBusMessageCopy
instance O.OverloadedMethodInfo DBusMessageCopyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageCopy"
})
#endif
foreign import ccall "g_dbus_message_get_arg0" g_dbus_message_get_arg0 ::
Ptr DBusMessage ->
IO CString
dBusMessageGetArg0 ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetArg0 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetArg0 a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_arg0 Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetArg0MethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetArg0MethodInfo a signature where
overloadedMethod = dBusMessageGetArg0
instance O.OverloadedMethodInfo DBusMessageGetArg0MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetArg0",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetArg0"
})
#endif
foreign import ccall "g_dbus_message_get_arg0_path" g_dbus_message_get_arg0_path ::
Ptr DBusMessage ->
IO CString
dBusMessageGetArg0Path ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetArg0Path :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetArg0Path a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_arg0_path Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetArg0PathMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetArg0PathMethodInfo a signature where
overloadedMethod = dBusMessageGetArg0Path
instance O.OverloadedMethodInfo DBusMessageGetArg0PathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetArg0Path",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetArg0Path"
})
#endif
foreign import ccall "g_dbus_message_get_body" g_dbus_message_get_body ::
Ptr DBusMessage ->
IO (Ptr GVariant)
dBusMessageGetBody ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe GVariant)
dBusMessageGetBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe GVariant)
dBusMessageGetBody a
message = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr GVariant
result <- Ptr DBusMessage -> IO (Ptr GVariant)
g_dbus_message_get_body Ptr DBusMessage
message'
Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe GVariant -> IO (Maybe GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetBodyMethodInfo
instance (signature ~ (m (Maybe GVariant)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetBodyMethodInfo a signature where
overloadedMethod = dBusMessageGetBody
instance O.OverloadedMethodInfo DBusMessageGetBodyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetBody",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetBody"
})
#endif
foreign import ccall "g_dbus_message_get_byte_order" g_dbus_message_get_byte_order ::
Ptr DBusMessage ->
IO CUInt
dBusMessageGetByteOrder ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Gio.Enums.DBusMessageByteOrder
dBusMessageGetByteOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m DBusMessageByteOrder
dBusMessageGetByteOrder a
message = IO DBusMessageByteOrder -> m DBusMessageByteOrder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessageByteOrder -> m DBusMessageByteOrder)
-> IO DBusMessageByteOrder -> m DBusMessageByteOrder
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
CUInt
result <- Ptr DBusMessage -> IO CUInt
g_dbus_message_get_byte_order Ptr DBusMessage
message'
let result' :: DBusMessageByteOrder
result' = (Int -> DBusMessageByteOrder
forall a. Enum a => Int -> a
toEnum (Int -> DBusMessageByteOrder)
-> (CUInt -> Int) -> CUInt -> DBusMessageByteOrder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
DBusMessageByteOrder -> IO DBusMessageByteOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessageByteOrder
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetByteOrderMethodInfo
instance (signature ~ (m Gio.Enums.DBusMessageByteOrder), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetByteOrderMethodInfo a signature where
overloadedMethod = dBusMessageGetByteOrder
instance O.OverloadedMethodInfo DBusMessageGetByteOrderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetByteOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetByteOrder"
})
#endif
foreign import ccall "g_dbus_message_get_destination" g_dbus_message_get_destination ::
Ptr DBusMessage ->
IO CString
dBusMessageGetDestination ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetDestination :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetDestination a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_destination Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetDestinationMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetDestinationMethodInfo a signature where
overloadedMethod = dBusMessageGetDestination
instance O.OverloadedMethodInfo DBusMessageGetDestinationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetDestination",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetDestination"
})
#endif
foreign import ccall "g_dbus_message_get_error_name" g_dbus_message_get_error_name ::
Ptr DBusMessage ->
IO CString
dBusMessageGetErrorName ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetErrorName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetErrorName a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_error_name Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetErrorNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetErrorNameMethodInfo a signature where
overloadedMethod = dBusMessageGetErrorName
instance O.OverloadedMethodInfo DBusMessageGetErrorNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetErrorName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetErrorName"
})
#endif
foreign import ccall "g_dbus_message_get_flags" g_dbus_message_get_flags ::
Ptr DBusMessage ->
IO CUInt
dBusMessageGetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m [Gio.Flags.DBusMessageFlags]
dBusMessageGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m [DBusMessageFlags]
dBusMessageGetFlags a
message = IO [DBusMessageFlags] -> m [DBusMessageFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DBusMessageFlags] -> m [DBusMessageFlags])
-> IO [DBusMessageFlags] -> m [DBusMessageFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
CUInt
result <- Ptr DBusMessage -> IO CUInt
g_dbus_message_get_flags Ptr DBusMessage
message'
let result' :: [DBusMessageFlags]
result' = CUInt -> [DBusMessageFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
[DBusMessageFlags] -> IO [DBusMessageFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusMessageFlags]
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetFlagsMethodInfo
instance (signature ~ (m [Gio.Flags.DBusMessageFlags]), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetFlagsMethodInfo a signature where
overloadedMethod = dBusMessageGetFlags
instance O.OverloadedMethodInfo DBusMessageGetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetFlags"
})
#endif
foreign import ccall "g_dbus_message_get_header" ::
Ptr DBusMessage ->
CUInt ->
IO (Ptr GVariant)
dBusMessageGetHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Gio.Enums.DBusMessageHeaderField
-> m (Maybe GVariant)
a
message DBusMessageHeaderField
headerField = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
let headerField' :: CUInt
headerField' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DBusMessageHeaderField -> Int)
-> DBusMessageHeaderField
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBusMessageHeaderField -> Int
forall a. Enum a => a -> Int
fromEnum) DBusMessageHeaderField
headerField
Ptr GVariant
result <- Ptr DBusMessage -> CUInt -> IO (Ptr GVariant)
g_dbus_message_get_header Ptr DBusMessage
message' CUInt
headerField'
Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe GVariant -> IO (Maybe GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetHeaderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> m (Maybe GVariant)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetHeaderMethodInfo a signature where
overloadedMethod = dBusMessageGetHeader
instance O.OverloadedMethodInfo DBusMessageGetHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetHeader"
})
#endif
foreign import ccall "g_dbus_message_get_header_fields" ::
Ptr DBusMessage ->
IO (Ptr Word8)
dBusMessageGetHeaderFields ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m ByteString
a
message = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr Word8
result <- Ptr DBusMessage -> IO (Ptr Word8)
g_dbus_message_get_header_fields Ptr DBusMessage
message'
Text -> Ptr Word8 -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageGetHeaderFields" Ptr Word8
result
ByteString
result' <- Ptr Word8 -> IO ByteString
unpackZeroTerminatedByteString Ptr Word8
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetHeaderFieldsMethodInfo
instance (signature ~ (m ByteString), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetHeaderFieldsMethodInfo a signature where
overloadedMethod = dBusMessageGetHeaderFields
instance O.OverloadedMethodInfo DBusMessageGetHeaderFieldsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetHeaderFields",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetHeaderFields"
})
#endif
foreign import ccall "g_dbus_message_get_interface" g_dbus_message_get_interface ::
Ptr DBusMessage ->
IO CString
dBusMessageGetInterface ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetInterface :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetInterface a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_interface Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetInterfaceMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetInterfaceMethodInfo a signature where
overloadedMethod = dBusMessageGetInterface
instance O.OverloadedMethodInfo DBusMessageGetInterfaceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetInterface",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetInterface"
})
#endif
foreign import ccall "g_dbus_message_get_locked" g_dbus_message_get_locked ::
Ptr DBusMessage ->
IO CInt
dBusMessageGetLocked ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Bool
dBusMessageGetLocked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m Bool
dBusMessageGetLocked a
message = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
CInt
result <- Ptr DBusMessage -> IO CInt
g_dbus_message_get_locked Ptr DBusMessage
message'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetLockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetLockedMethodInfo a signature where
overloadedMethod = dBusMessageGetLocked
instance O.OverloadedMethodInfo DBusMessageGetLockedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetLocked",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetLocked"
})
#endif
foreign import ccall "g_dbus_message_get_member" g_dbus_message_get_member ::
Ptr DBusMessage ->
IO CString
dBusMessageGetMember ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetMember :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetMember a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_member Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetMemberMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetMemberMethodInfo a signature where
overloadedMethod = dBusMessageGetMember
instance O.OverloadedMethodInfo DBusMessageGetMemberMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetMember",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetMember"
})
#endif
foreign import ccall "g_dbus_message_get_message_type" g_dbus_message_get_message_type ::
Ptr DBusMessage ->
IO CUInt
dBusMessageGetMessageType ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Gio.Enums.DBusMessageType
dBusMessageGetMessageType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m DBusMessageType
dBusMessageGetMessageType a
message = IO DBusMessageType -> m DBusMessageType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessageType -> m DBusMessageType)
-> IO DBusMessageType -> m DBusMessageType
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
CUInt
result <- Ptr DBusMessage -> IO CUInt
g_dbus_message_get_message_type Ptr DBusMessage
message'
let result' :: DBusMessageType
result' = (Int -> DBusMessageType
forall a. Enum a => Int -> a
toEnum (Int -> DBusMessageType)
-> (CUInt -> Int) -> CUInt -> DBusMessageType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
DBusMessageType -> IO DBusMessageType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessageType
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetMessageTypeMethodInfo
instance (signature ~ (m Gio.Enums.DBusMessageType), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetMessageTypeMethodInfo a signature where
overloadedMethod = dBusMessageGetMessageType
instance O.OverloadedMethodInfo DBusMessageGetMessageTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetMessageType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetMessageType"
})
#endif
foreign import ccall "g_dbus_message_get_num_unix_fds" g_dbus_message_get_num_unix_fds ::
Ptr DBusMessage ->
IO Word32
dBusMessageGetNumUnixFds ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Word32
dBusMessageGetNumUnixFds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m Word32
dBusMessageGetNumUnixFds a
message = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Word32
result <- Ptr DBusMessage -> IO Word32
g_dbus_message_get_num_unix_fds Ptr DBusMessage
message'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetNumUnixFdsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetNumUnixFdsMethodInfo a signature where
overloadedMethod = dBusMessageGetNumUnixFds
instance O.OverloadedMethodInfo DBusMessageGetNumUnixFdsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetNumUnixFds",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetNumUnixFds"
})
#endif
foreign import ccall "g_dbus_message_get_path" g_dbus_message_get_path ::
Ptr DBusMessage ->
IO CString
dBusMessageGetPath ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetPath a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_path Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetPathMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetPathMethodInfo a signature where
overloadedMethod = dBusMessageGetPath
instance O.OverloadedMethodInfo DBusMessageGetPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetPath"
})
#endif
foreign import ccall "g_dbus_message_get_reply_serial" g_dbus_message_get_reply_serial ::
Ptr DBusMessage ->
IO Word32
dBusMessageGetReplySerial ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Word32
dBusMessageGetReplySerial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m Word32
dBusMessageGetReplySerial a
message = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Word32
result <- Ptr DBusMessage -> IO Word32
g_dbus_message_get_reply_serial Ptr DBusMessage
message'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetReplySerialMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetReplySerialMethodInfo a signature where
overloadedMethod = dBusMessageGetReplySerial
instance O.OverloadedMethodInfo DBusMessageGetReplySerialMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetReplySerial",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetReplySerial"
})
#endif
foreign import ccall "g_dbus_message_get_sender" g_dbus_message_get_sender ::
Ptr DBusMessage ->
IO CString
dBusMessageGetSender ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe T.Text)
dBusMessageGetSender :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe Text)
dBusMessageGetSender a
message = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_sender Ptr DBusMessage
message'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetSenderMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetSenderMethodInfo a signature where
overloadedMethod = dBusMessageGetSender
instance O.OverloadedMethodInfo DBusMessageGetSenderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetSender",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetSender"
})
#endif
foreign import ccall "g_dbus_message_get_serial" g_dbus_message_get_serial ::
Ptr DBusMessage ->
IO Word32
dBusMessageGetSerial ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m Word32
dBusMessageGetSerial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m Word32
dBusMessageGetSerial a
message = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Word32
result <- Ptr DBusMessage -> IO Word32
g_dbus_message_get_serial Ptr DBusMessage
message'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetSerialMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetSerialMethodInfo a signature where
overloadedMethod = dBusMessageGetSerial
instance O.OverloadedMethodInfo DBusMessageGetSerialMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetSerial",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetSerial"
})
#endif
foreign import ccall "g_dbus_message_get_signature" g_dbus_message_get_signature ::
Ptr DBusMessage ->
IO CString
dBusMessageGetSignature ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m T.Text
dBusMessageGetSignature :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m Text
dBusMessageGetSignature a
message = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> IO (Ptr CChar)
g_dbus_message_get_signature Ptr DBusMessage
message'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageGetSignature" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetSignatureMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetSignatureMethodInfo a signature where
overloadedMethod = dBusMessageGetSignature
instance O.OverloadedMethodInfo DBusMessageGetSignatureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetSignature",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetSignature"
})
#endif
foreign import ccall "g_dbus_message_get_unix_fd_list" g_dbus_message_get_unix_fd_list ::
Ptr DBusMessage ->
IO (Ptr Gio.UnixFDList.UnixFDList)
dBusMessageGetUnixFdList ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m (Maybe Gio.UnixFDList.UnixFDList)
dBusMessageGetUnixFdList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m (Maybe UnixFDList)
dBusMessageGetUnixFdList a
message = IO (Maybe UnixFDList) -> m (Maybe UnixFDList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe UnixFDList) -> m (Maybe UnixFDList))
-> IO (Maybe UnixFDList) -> m (Maybe UnixFDList)
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr UnixFDList
result <- Ptr DBusMessage -> IO (Ptr UnixFDList)
g_dbus_message_get_unix_fd_list Ptr DBusMessage
message'
Maybe UnixFDList
maybeResult <- Ptr UnixFDList
-> (Ptr UnixFDList -> IO UnixFDList) -> IO (Maybe UnixFDList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr UnixFDList
result ((Ptr UnixFDList -> IO UnixFDList) -> IO (Maybe UnixFDList))
-> (Ptr UnixFDList -> IO UnixFDList) -> IO (Maybe UnixFDList)
forall a b. (a -> b) -> a -> b
$ \Ptr UnixFDList
result' -> do
UnixFDList
result'' <- ((ManagedPtr UnixFDList -> UnixFDList)
-> Ptr UnixFDList -> IO UnixFDList
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr UnixFDList -> UnixFDList
Gio.UnixFDList.UnixFDList) Ptr UnixFDList
result'
UnixFDList -> IO UnixFDList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return UnixFDList
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe UnixFDList -> IO (Maybe UnixFDList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UnixFDList
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusMessageGetUnixFdListMethodInfo
instance (signature ~ (m (Maybe Gio.UnixFDList.UnixFDList)), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageGetUnixFdListMethodInfo a signature where
overloadedMethod = dBusMessageGetUnixFdList
instance O.OverloadedMethodInfo DBusMessageGetUnixFdListMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageGetUnixFdList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageGetUnixFdList"
})
#endif
foreign import ccall "g_dbus_message_lock" g_dbus_message_lock ::
Ptr DBusMessage ->
IO ()
dBusMessageLock ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m ()
dBusMessageLock :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m ()
dBusMessageLock a
message = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr DBusMessage -> IO ()
g_dbus_message_lock Ptr DBusMessage
message'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageLockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageLockMethodInfo a signature where
overloadedMethod = dBusMessageLock
instance O.OverloadedMethodInfo DBusMessageLockMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageLock",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageLock"
})
#endif
foreign import ccall "g_dbus_message_new_method_error_literal" g_dbus_message_new_method_error_literal ::
Ptr DBusMessage ->
CString ->
CString ->
IO (Ptr DBusMessage)
dBusMessageNewMethodErrorLiteral ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> T.Text
-> T.Text
-> m DBusMessage
dBusMessageNewMethodErrorLiteral :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Text -> Text -> m DBusMessage
dBusMessageNewMethodErrorLiteral a
methodCallMessage Text
errorName Text
errorMessage = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
methodCallMessage' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
methodCallMessage
Ptr CChar
errorName' <- Text -> IO (Ptr CChar)
textToCString Text
errorName
Ptr CChar
errorMessage' <- Text -> IO (Ptr CChar)
textToCString Text
errorMessage
Ptr DBusMessage
result <- Ptr DBusMessage -> Ptr CChar -> Ptr CChar -> IO (Ptr DBusMessage)
g_dbus_message_new_method_error_literal Ptr DBusMessage
methodCallMessage' Ptr CChar
errorName' Ptr CChar
errorMessage'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNewMethodErrorLiteral" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
methodCallMessage
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
errorName'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
errorMessage'
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageNewMethodErrorLiteralMethodInfo
instance (signature ~ (T.Text -> T.Text -> m DBusMessage), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageNewMethodErrorLiteralMethodInfo a signature where
overloadedMethod = dBusMessageNewMethodErrorLiteral
instance O.OverloadedMethodInfo DBusMessageNewMethodErrorLiteralMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageNewMethodErrorLiteral",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageNewMethodErrorLiteral"
})
#endif
foreign import ccall "g_dbus_message_new_method_reply" g_dbus_message_new_method_reply ::
Ptr DBusMessage ->
IO (Ptr DBusMessage)
dBusMessageNewMethodReply ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m DBusMessage
dBusMessageNewMethodReply :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m DBusMessage
dBusMessageNewMethodReply a
methodCallMessage = IO DBusMessage -> m DBusMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMessage -> m DBusMessage)
-> IO DBusMessage -> m DBusMessage
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
methodCallMessage' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
methodCallMessage
Ptr DBusMessage
result <- Ptr DBusMessage -> IO (Ptr DBusMessage)
g_dbus_message_new_method_reply Ptr DBusMessage
methodCallMessage'
Text -> Ptr DBusMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageNewMethodReply" Ptr DBusMessage
result
DBusMessage
result' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
DBusMessage) Ptr DBusMessage
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
methodCallMessage
DBusMessage -> IO DBusMessage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMessage
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessageNewMethodReplyMethodInfo
instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageNewMethodReplyMethodInfo a signature where
overloadedMethod = dBusMessageNewMethodReply
instance O.OverloadedMethodInfo DBusMessageNewMethodReplyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageNewMethodReply",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageNewMethodReply"
})
#endif
foreign import ccall "g_dbus_message_print" g_dbus_message_print ::
Ptr DBusMessage ->
Word32 ->
IO CString
dBusMessagePrint ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Word32
-> m T.Text
dBusMessagePrint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Word32 -> m Text
dBusMessagePrint a
message Word32
indent = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
result <- Ptr DBusMessage -> Word32 -> IO (Ptr CChar)
g_dbus_message_print Ptr DBusMessage
message' Word32
indent
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessagePrint" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DBusMessagePrintMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessagePrintMethodInfo a signature where
overloadedMethod = dBusMessagePrint
instance O.OverloadedMethodInfo DBusMessagePrintMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessagePrint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessagePrint"
})
#endif
foreign import ccall "g_dbus_message_set_body" g_dbus_message_set_body ::
Ptr DBusMessage ->
Ptr GVariant ->
IO ()
dBusMessageSetBody ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> GVariant
-> m ()
dBusMessageSetBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> GVariant -> m ()
dBusMessageSetBody a
message GVariant
body = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr GVariant
body' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
body
Ptr DBusMessage -> Ptr GVariant -> IO ()
g_dbus_message_set_body Ptr DBusMessage
message' Ptr GVariant
body'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
body
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetBodyMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetBodyMethodInfo a signature where
overloadedMethod = dBusMessageSetBody
instance O.OverloadedMethodInfo DBusMessageSetBodyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetBody",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetBody"
})
#endif
foreign import ccall "g_dbus_message_set_byte_order" g_dbus_message_set_byte_order ::
Ptr DBusMessage ->
CUInt ->
IO ()
dBusMessageSetByteOrder ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Gio.Enums.DBusMessageByteOrder
-> m ()
dBusMessageSetByteOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> DBusMessageByteOrder -> m ()
dBusMessageSetByteOrder a
message DBusMessageByteOrder
byteOrder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
let byteOrder' :: CUInt
byteOrder' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DBusMessageByteOrder -> Int) -> DBusMessageByteOrder -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBusMessageByteOrder -> Int
forall a. Enum a => a -> Int
fromEnum) DBusMessageByteOrder
byteOrder
Ptr DBusMessage -> CUInt -> IO ()
g_dbus_message_set_byte_order Ptr DBusMessage
message' CUInt
byteOrder'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetByteOrderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageByteOrder -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetByteOrderMethodInfo a signature where
overloadedMethod = dBusMessageSetByteOrder
instance O.OverloadedMethodInfo DBusMessageSetByteOrderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetByteOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetByteOrder"
})
#endif
foreign import ccall "g_dbus_message_set_destination" g_dbus_message_set_destination ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetDestination ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetDestination :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetDestination a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_destination Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetDestinationMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetDestinationMethodInfo a signature where
overloadedMethod = dBusMessageSetDestination
instance O.OverloadedMethodInfo DBusMessageSetDestinationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetDestination",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetDestination"
})
#endif
foreign import ccall "g_dbus_message_set_error_name" g_dbus_message_set_error_name ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetErrorName ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
Maybe (a)
-> T.Text
-> m ()
dBusMessageSetErrorName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
Maybe a -> Text -> m ()
dBusMessageSetErrorName Maybe a
message Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
maybeMessage <- case Maybe a
message of
Maybe a
Nothing -> Ptr DBusMessage -> IO (Ptr DBusMessage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DBusMessage
forall a. Ptr a
nullPtr
Just a
jMessage -> do
Ptr DBusMessage
jMessage' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jMessage
Ptr DBusMessage -> IO (Ptr DBusMessage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DBusMessage
jMessage'
Ptr CChar
value' <- Text -> IO (Ptr CChar)
textToCString Text
value
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_error_name Ptr DBusMessage
maybeMessage Ptr CChar
value'
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
message a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
value'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetErrorNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetErrorNameMethodInfo a signature where
overloadedMethod i = dBusMessageSetErrorName (Just i)
instance O.OverloadedMethodInfo DBusMessageSetErrorNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetErrorName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetErrorName"
})
#endif
foreign import ccall "g_dbus_message_set_flags" g_dbus_message_set_flags ::
Ptr DBusMessage ->
CUInt ->
IO ()
dBusMessageSetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> [Gio.Flags.DBusMessageFlags]
-> m ()
dBusMessageSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> [DBusMessageFlags] -> m ()
dBusMessageSetFlags a
message [DBusMessageFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
let flags' :: CUInt
flags' = [DBusMessageFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DBusMessageFlags]
flags
Ptr DBusMessage -> CUInt -> IO ()
g_dbus_message_set_flags Ptr DBusMessage
message' CUInt
flags'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetFlagsMethodInfo
instance (signature ~ ([Gio.Flags.DBusMessageFlags] -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetFlagsMethodInfo a signature where
overloadedMethod = dBusMessageSetFlags
instance O.OverloadedMethodInfo DBusMessageSetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetFlags"
})
#endif
foreign import ccall "g_dbus_message_set_header" ::
Ptr DBusMessage ->
CUInt ->
Ptr GVariant ->
IO ()
dBusMessageSetHeader ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Gio.Enums.DBusMessageHeaderField
-> Maybe (GVariant)
-> m ()
a
message DBusMessageHeaderField
headerField Maybe GVariant
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
let headerField' :: CUInt
headerField' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DBusMessageHeaderField -> Int)
-> DBusMessageHeaderField
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBusMessageHeaderField -> Int
forall a. Enum a => a -> Int
fromEnum) DBusMessageHeaderField
headerField
Ptr GVariant
maybeValue <- case Maybe GVariant
value of
Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
Just GVariant
jValue -> do
Ptr GVariant
jValue' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jValue
Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jValue'
Ptr DBusMessage -> CUInt -> Ptr GVariant -> IO ()
g_dbus_message_set_header Ptr DBusMessage
message' CUInt
headerField' Ptr GVariant
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
value GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetHeaderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> Maybe (GVariant) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetHeaderMethodInfo a signature where
overloadedMethod = dBusMessageSetHeader
instance O.OverloadedMethodInfo DBusMessageSetHeaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetHeader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetHeader"
})
#endif
foreign import ccall "g_dbus_message_set_interface" g_dbus_message_set_interface ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetInterface ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetInterface :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetInterface a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_interface Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetInterfaceMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetInterfaceMethodInfo a signature where
overloadedMethod = dBusMessageSetInterface
instance O.OverloadedMethodInfo DBusMessageSetInterfaceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetInterface",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetInterface"
})
#endif
foreign import ccall "g_dbus_message_set_member" g_dbus_message_set_member ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetMember ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetMember :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetMember a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_member Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetMemberMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetMemberMethodInfo a signature where
overloadedMethod = dBusMessageSetMember
instance O.OverloadedMethodInfo DBusMessageSetMemberMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetMember",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetMember"
})
#endif
foreign import ccall "g_dbus_message_set_message_type" g_dbus_message_set_message_type ::
Ptr DBusMessage ->
CUInt ->
IO ()
dBusMessageSetMessageType ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Gio.Enums.DBusMessageType
-> m ()
dBusMessageSetMessageType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> DBusMessageType -> m ()
dBusMessageSetMessageType a
message DBusMessageType
type_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DBusMessageType -> Int) -> DBusMessageType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DBusMessageType -> Int
forall a. Enum a => a -> Int
fromEnum) DBusMessageType
type_
Ptr DBusMessage -> CUInt -> IO ()
g_dbus_message_set_message_type Ptr DBusMessage
message' CUInt
type_'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetMessageTypeMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageType -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetMessageTypeMethodInfo a signature where
overloadedMethod = dBusMessageSetMessageType
instance O.OverloadedMethodInfo DBusMessageSetMessageTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetMessageType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetMessageType"
})
#endif
foreign import ccall "g_dbus_message_set_num_unix_fds" g_dbus_message_set_num_unix_fds ::
Ptr DBusMessage ->
Word32 ->
IO ()
dBusMessageSetNumUnixFds ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Word32
-> m ()
dBusMessageSetNumUnixFds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Word32 -> m ()
dBusMessageSetNumUnixFds a
message Word32
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr DBusMessage -> Word32 -> IO ()
g_dbus_message_set_num_unix_fds Ptr DBusMessage
message' Word32
value
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetNumUnixFdsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetNumUnixFdsMethodInfo a signature where
overloadedMethod = dBusMessageSetNumUnixFds
instance O.OverloadedMethodInfo DBusMessageSetNumUnixFdsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetNumUnixFds",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetNumUnixFds"
})
#endif
foreign import ccall "g_dbus_message_set_path" g_dbus_message_set_path ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetPath ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetPath a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_path Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetPathMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetPathMethodInfo a signature where
overloadedMethod = dBusMessageSetPath
instance O.OverloadedMethodInfo DBusMessageSetPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetPath"
})
#endif
foreign import ccall "g_dbus_message_set_reply_serial" g_dbus_message_set_reply_serial ::
Ptr DBusMessage ->
Word32 ->
IO ()
dBusMessageSetReplySerial ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Word32
-> m ()
dBusMessageSetReplySerial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Word32 -> m ()
dBusMessageSetReplySerial a
message Word32
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr DBusMessage -> Word32 -> IO ()
g_dbus_message_set_reply_serial Ptr DBusMessage
message' Word32
value
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetReplySerialMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetReplySerialMethodInfo a signature where
overloadedMethod = dBusMessageSetReplySerial
instance O.OverloadedMethodInfo DBusMessageSetReplySerialMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetReplySerial",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetReplySerial"
})
#endif
foreign import ccall "g_dbus_message_set_sender" g_dbus_message_set_sender ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetSender ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetSender :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetSender a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_sender Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetSenderMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetSenderMethodInfo a signature where
overloadedMethod = dBusMessageSetSender
instance O.OverloadedMethodInfo DBusMessageSetSenderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetSender",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetSender"
})
#endif
foreign import ccall "g_dbus_message_set_serial" g_dbus_message_set_serial ::
Ptr DBusMessage ->
Word32 ->
IO ()
dBusMessageSetSerial ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Word32
-> m ()
dBusMessageSetSerial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Word32 -> m ()
dBusMessageSetSerial a
message Word32
serial = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr DBusMessage -> Word32 -> IO ()
g_dbus_message_set_serial Ptr DBusMessage
message' Word32
serial
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetSerialMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetSerialMethodInfo a signature where
overloadedMethod = dBusMessageSetSerial
instance O.OverloadedMethodInfo DBusMessageSetSerialMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetSerial",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetSerial"
})
#endif
foreign import ccall "g_dbus_message_set_signature" g_dbus_message_set_signature ::
Ptr DBusMessage ->
CString ->
IO ()
dBusMessageSetSignature ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> Maybe (T.Text)
-> m ()
dBusMessageSetSignature :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> Maybe Text -> m ()
dBusMessageSetSignature a
message Maybe Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CChar
maybeValue <- case Maybe Text
value of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jValue -> do
Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
Ptr DBusMessage -> Ptr CChar -> IO ()
g_dbus_message_set_signature Ptr DBusMessage
message' Ptr CChar
maybeValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetSignatureMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageSetSignatureMethodInfo a signature where
overloadedMethod = dBusMessageSetSignature
instance O.OverloadedMethodInfo DBusMessageSetSignatureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetSignature",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetSignature"
})
#endif
foreign import ccall "g_dbus_message_set_unix_fd_list" g_dbus_message_set_unix_fd_list ::
Ptr DBusMessage ->
Ptr Gio.UnixFDList.UnixFDList ->
IO ()
dBusMessageSetUnixFdList ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) =>
a
-> Maybe (b)
-> m ()
dBusMessageSetUnixFdList :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusMessage a, IsUnixFDList b) =>
a -> Maybe b -> m ()
dBusMessageSetUnixFdList a
message Maybe b
fdList = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr UnixFDList
maybeFdList <- case Maybe b
fdList of
Maybe b
Nothing -> Ptr UnixFDList -> IO (Ptr UnixFDList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr UnixFDList
forall a. Ptr a
nullPtr
Just b
jFdList -> do
Ptr UnixFDList
jFdList' <- b -> IO (Ptr UnixFDList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFdList
Ptr UnixFDList -> IO (Ptr UnixFDList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr UnixFDList
jFdList'
Ptr DBusMessage -> Ptr UnixFDList -> IO ()
g_dbus_message_set_unix_fd_list Ptr DBusMessage
message' Ptr UnixFDList
maybeFdList
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
fdList b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusMessageSetUnixFdListMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) => O.OverloadedMethod DBusMessageSetUnixFdListMethodInfo a signature where
overloadedMethod = dBusMessageSetUnixFdList
instance O.OverloadedMethodInfo DBusMessageSetUnixFdListMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageSetUnixFdList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageSetUnixFdList"
})
#endif
foreign import ccall "g_dbus_message_to_blob" g_dbus_message_to_blob ::
Ptr DBusMessage ->
Ptr FCT.CSize ->
CUInt ->
Ptr (Ptr GError) ->
IO (Ptr Word8)
dBusMessageToBlob ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> [Gio.Flags.DBusCapabilityFlags]
-> m ByteString
dBusMessageToBlob :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> [DBusCapabilityFlags] -> m ByteString
dBusMessageToBlob a
message [DBusCapabilityFlags]
capabilities = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr CSize
outSize <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
let capabilities' :: CUInt
capabilities' = [DBusCapabilityFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DBusCapabilityFlags]
capabilities
IO ByteString -> IO () -> IO ByteString
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Word8
result <- (Ptr (Ptr GError) -> IO (Ptr Word8)) -> IO (Ptr Word8)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Word8)) -> IO (Ptr Word8))
-> (Ptr (Ptr GError) -> IO (Ptr Word8)) -> IO (Ptr Word8)
forall a b. (a -> b) -> a -> b
$ Ptr DBusMessage
-> Ptr CSize -> CUInt -> Ptr (Ptr GError) -> IO (Ptr Word8)
g_dbus_message_to_blob Ptr DBusMessage
message' Ptr CSize
outSize CUInt
capabilities'
CSize
outSize' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
outSize
Text -> Ptr Word8 -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusMessageToBlob" Ptr Word8
result
ByteString
result' <- (CSize -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength CSize
outSize') Ptr Word8
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
outSize
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
) (do
Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
outSize
)
#if defined(ENABLE_OVERLOADING)
data DBusMessageToBlobMethodInfo
instance (signature ~ ([Gio.Flags.DBusCapabilityFlags] -> m ByteString), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageToBlobMethodInfo a signature where
overloadedMethod = dBusMessageToBlob
instance O.OverloadedMethodInfo DBusMessageToBlobMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageToBlob",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageToBlob"
})
#endif
foreign import ccall "g_dbus_message_to_gerror" g_dbus_message_to_gerror ::
Ptr DBusMessage ->
Ptr (Ptr GError) ->
IO CInt
dBusMessageToGerror ::
(B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
a
-> m ()
dBusMessageToGerror :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusMessage a) =>
a -> m ()
dBusMessageToGerror a
message = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusMessage
message' <- a -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr DBusMessage -> Ptr (Ptr GError) -> IO CInt
g_dbus_message_to_gerror Ptr DBusMessage
message'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data DBusMessageToGerrorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.OverloadedMethod DBusMessageToGerrorMethodInfo a signature where
overloadedMethod = dBusMessageToGerror
instance O.OverloadedMethodInfo DBusMessageToGerrorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DBusMessage.dBusMessageToGerror",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.33/docs/GI-Gio-Objects-DBusMessage.html#v:dBusMessageToGerror"
})
#endif
foreign import ccall "g_dbus_message_bytes_needed" g_dbus_message_bytes_needed ::
Ptr Word8 ->
FCT.CSize ->
Ptr (Ptr GError) ->
IO DI.Int64
dBusMessageBytesNeeded ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m DI.Int64
dBusMessageBytesNeeded :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Int64
dBusMessageBytesNeeded ByteString
blob = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
let blobLen :: CSize
blobLen = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
blob
Ptr Word8
blob' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
blob
IO Int64 -> IO () -> IO Int64
forall a b. IO a -> IO b -> IO a
onException (do
Int64
result <- (Ptr (Ptr GError) -> IO Int64) -> IO Int64
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Int64) -> IO Int64)
-> (Ptr (Ptr GError) -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ Ptr Word8 -> CSize -> Ptr (Ptr GError) -> IO Int64
g_dbus_message_bytes_needed Ptr Word8
blob' CSize
blobLen
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
blob'
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
) (do
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
blob'
)
#if defined(ENABLE_OVERLOADING)
#endif