{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.DBusSignalInfo
(
DBusSignalInfo(..) ,
newZeroDBusSignalInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusSignalInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DBusSignalInfoRefMethodInfo ,
#endif
dBusSignalInfoRef ,
#if defined(ENABLE_OVERLOADING)
DBusSignalInfoUnrefMethodInfo ,
#endif
dBusSignalInfoUnref ,
clearDBusSignalInfoAnnotations ,
#if defined(ENABLE_OVERLOADING)
dBusSignalInfo_annotations ,
#endif
getDBusSignalInfoAnnotations ,
setDBusSignalInfoAnnotations ,
clearDBusSignalInfoArgs ,
#if defined(ENABLE_OVERLOADING)
dBusSignalInfo_args ,
#endif
getDBusSignalInfoArgs ,
setDBusSignalInfoArgs ,
clearDBusSignalInfoName ,
#if defined(ENABLE_OVERLOADING)
dBusSignalInfo_name ,
#endif
getDBusSignalInfoName ,
setDBusSignalInfoName ,
#if defined(ENABLE_OVERLOADING)
dBusSignalInfo_refCount ,
#endif
getDBusSignalInfoRefCount ,
setDBusSignalInfoRefCount ,
) 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.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 {-# SOURCE #-} qualified GI.Gio.Structs.DBusAnnotationInfo as Gio.DBusAnnotationInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusArgInfo as Gio.DBusArgInfo
newtype DBusSignalInfo = DBusSignalInfo (SP.ManagedPtr DBusSignalInfo)
deriving (DBusSignalInfo -> DBusSignalInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusSignalInfo -> DBusSignalInfo -> Bool
$c/= :: DBusSignalInfo -> DBusSignalInfo -> Bool
== :: DBusSignalInfo -> DBusSignalInfo -> Bool
$c== :: DBusSignalInfo -> DBusSignalInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusSignalInfo where
toManagedPtr :: DBusSignalInfo -> ManagedPtr DBusSignalInfo
toManagedPtr (DBusSignalInfo ManagedPtr DBusSignalInfo
p) = ManagedPtr DBusSignalInfo
p
foreign import ccall "g_dbus_signal_info_get_type" c_g_dbus_signal_info_get_type ::
IO GType
type instance O.ParentTypes DBusSignalInfo = '[]
instance O.HasParentTypes DBusSignalInfo
instance B.Types.TypedObject DBusSignalInfo where
glibType :: IO GType
glibType = IO GType
c_g_dbus_signal_info_get_type
instance B.Types.GBoxed DBusSignalInfo
instance B.GValue.IsGValue (Maybe DBusSignalInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_signal_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusSignalInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusSignalInfo
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusSignalInfo)
gvalueSet_ Ptr GValue
gv (P.Just DBusSignalInfo
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusSignalInfo
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusSignalInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr DBusSignalInfo
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DBusSignalInfo)
if Ptr DBusSignalInfo
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
DBusSignalInfo Ptr DBusSignalInfo
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroDBusSignalInfo :: MonadIO m => m DBusSignalInfo
newZeroDBusSignalInfo :: forall (m :: * -> *). MonadIO m => m DBusSignalInfo
newZeroDBusSignalInfo = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
DBusSignalInfo
instance tag ~ 'AttrSet => Constructible DBusSignalInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DBusSignalInfo -> DBusSignalInfo)
-> [AttrOp DBusSignalInfo tag] -> m DBusSignalInfo
new ManagedPtr DBusSignalInfo -> DBusSignalInfo
_ [AttrOp DBusSignalInfo tag]
attrs = do
DBusSignalInfo
o <- forall (m :: * -> *). MonadIO m => m DBusSignalInfo
newZeroDBusSignalInfo
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DBusSignalInfo
o [AttrOp DBusSignalInfo tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return DBusSignalInfo
o
getDBusSignalInfoRefCount :: MonadIO m => DBusSignalInfo -> m Int32
getDBusSignalInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> m Int32
getDBusSignalInfoRefCount DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDBusSignalInfoRefCount :: MonadIO m => DBusSignalInfo -> Int32 -> m ()
setDBusSignalInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> Int32 -> m ()
setDBusSignalInfoRefCount DBusSignalInfo
s Int32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoRefCountFieldInfo
instance AttrInfo DBusSignalInfoRefCountFieldInfo where
type AttrBaseTypeConstraint DBusSignalInfoRefCountFieldInfo = (~) DBusSignalInfo
type AttrAllowedOps DBusSignalInfoRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DBusSignalInfoRefCountFieldInfo = (~) Int32
type AttrTransferTypeConstraint DBusSignalInfoRefCountFieldInfo = (~)Int32
type AttrTransferType DBusSignalInfoRefCountFieldInfo = Int32
type AttrGetType DBusSignalInfoRefCountFieldInfo = Int32
type AttrLabel DBusSignalInfoRefCountFieldInfo = "ref_count"
type AttrOrigin DBusSignalInfoRefCountFieldInfo = DBusSignalInfo
attrGet = getDBusSignalInfoRefCount
attrSet = setDBusSignalInfoRefCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.refCount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#g:attr:refCount"
})
dBusSignalInfo_refCount :: AttrLabelProxy "refCount"
dBusSignalInfo_refCount = AttrLabelProxy
#endif
getDBusSignalInfoName :: MonadIO m => DBusSignalInfo -> m (Maybe T.Text)
getDBusSignalInfoName :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> m (Maybe Text)
getDBusSignalInfoName DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setDBusSignalInfoName :: MonadIO m => DBusSignalInfo -> CString -> m ()
setDBusSignalInfoName :: forall (m :: * -> *).
MonadIO m =>
DBusSignalInfo -> CString -> m ()
setDBusSignalInfoName DBusSignalInfo
s CString
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CString
val :: CString)
clearDBusSignalInfoName :: MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoName :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoName DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoNameFieldInfo
instance AttrInfo DBusSignalInfoNameFieldInfo where
type AttrBaseTypeConstraint DBusSignalInfoNameFieldInfo = (~) DBusSignalInfo
type AttrAllowedOps DBusSignalInfoNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusSignalInfoNameFieldInfo = (~) CString
type AttrTransferTypeConstraint DBusSignalInfoNameFieldInfo = (~)CString
type AttrTransferType DBusSignalInfoNameFieldInfo = CString
type AttrGetType DBusSignalInfoNameFieldInfo = Maybe T.Text
type AttrLabel DBusSignalInfoNameFieldInfo = "name"
type AttrOrigin DBusSignalInfoNameFieldInfo = DBusSignalInfo
attrGet = getDBusSignalInfoName
attrSet = setDBusSignalInfoName
attrConstruct = undefined
attrClear = clearDBusSignalInfoName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#g:attr:name"
})
dBusSignalInfo_name :: AttrLabelProxy "name"
dBusSignalInfo_name = AttrLabelProxy
#endif
getDBusSignalInfoArgs :: MonadIO m => DBusSignalInfo -> m (Maybe [Gio.DBusArgInfo.DBusArgInfo])
getDBusSignalInfoArgs :: forall (m :: * -> *).
MonadIO m =>
DBusSignalInfo -> m (Maybe [DBusArgInfo])
getDBusSignalInfoArgs DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
Ptr (Ptr DBusArgInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
Maybe [DBusArgInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusArgInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusArgInfo)
val' -> do
[Ptr DBusArgInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusArgInfo)
val'
[DBusArgInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusArgInfo -> DBusArgInfo
Gio.DBusArgInfo.DBusArgInfo) [Ptr DBusArgInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusArgInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusArgInfo]
result
setDBusSignalInfoArgs :: MonadIO m => DBusSignalInfo -> Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo) -> m ()
setDBusSignalInfoArgs :: forall (m :: * -> *).
MonadIO m =>
DBusSignalInfo -> Ptr (Ptr DBusArgInfo) -> m ()
setDBusSignalInfoArgs DBusSignalInfo
s Ptr (Ptr DBusArgInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr (Ptr DBusArgInfo)
val :: Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
clearDBusSignalInfoArgs :: MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoArgs :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoArgs DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoArgsFieldInfo
instance AttrInfo DBusSignalInfoArgsFieldInfo where
type AttrBaseTypeConstraint DBusSignalInfoArgsFieldInfo = (~) DBusSignalInfo
type AttrAllowedOps DBusSignalInfoArgsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusSignalInfoArgsFieldInfo = (~) (Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
type AttrTransferTypeConstraint DBusSignalInfoArgsFieldInfo = (~)(Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
type AttrTransferType DBusSignalInfoArgsFieldInfo = (Ptr (Ptr Gio.DBusArgInfo.DBusArgInfo))
type AttrGetType DBusSignalInfoArgsFieldInfo = Maybe [Gio.DBusArgInfo.DBusArgInfo]
type AttrLabel DBusSignalInfoArgsFieldInfo = "args"
type AttrOrigin DBusSignalInfoArgsFieldInfo = DBusSignalInfo
attrGet = getDBusSignalInfoArgs
attrSet = setDBusSignalInfoArgs
attrConstruct = undefined
attrClear = clearDBusSignalInfoArgs
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.args"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#g:attr:args"
})
dBusSignalInfo_args :: AttrLabelProxy "args"
dBusSignalInfo_args = AttrLabelProxy
#endif
getDBusSignalInfoAnnotations :: MonadIO m => DBusSignalInfo -> m (Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo])
getDBusSignalInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusSignalInfo -> m (Maybe [DBusAnnotationInfo])
getDBusSignalInfoAnnotations DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
Ptr (Ptr DBusAnnotationInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
Maybe [DBusAnnotationInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusAnnotationInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusAnnotationInfo)
val' -> do
[Ptr DBusAnnotationInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusAnnotationInfo)
val'
[DBusAnnotationInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo
Gio.DBusAnnotationInfo.DBusAnnotationInfo) [Ptr DBusAnnotationInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusAnnotationInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusAnnotationInfo]
result
setDBusSignalInfoAnnotations :: MonadIO m => DBusSignalInfo -> Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo) -> m ()
setDBusSignalInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusSignalInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusSignalInfoAnnotations DBusSignalInfo
s Ptr (Ptr DBusAnnotationInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr (Ptr DBusAnnotationInfo)
val :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
clearDBusSignalInfoAnnotations :: MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoAnnotations :: forall (m :: * -> *). MonadIO m => DBusSignalInfo -> m ()
clearDBusSignalInfoAnnotations DBusSignalInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusSignalInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusSignalInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoAnnotationsFieldInfo
instance AttrInfo DBusSignalInfoAnnotationsFieldInfo where
type AttrBaseTypeConstraint DBusSignalInfoAnnotationsFieldInfo = (~) DBusSignalInfo
type AttrAllowedOps DBusSignalInfoAnnotationsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusSignalInfoAnnotationsFieldInfo = (~) (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferTypeConstraint DBusSignalInfoAnnotationsFieldInfo = (~)(Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferType DBusSignalInfoAnnotationsFieldInfo = (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrGetType DBusSignalInfoAnnotationsFieldInfo = Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo]
type AttrLabel DBusSignalInfoAnnotationsFieldInfo = "annotations"
type AttrOrigin DBusSignalInfoAnnotationsFieldInfo = DBusSignalInfo
attrGet = getDBusSignalInfoAnnotations
attrSet = setDBusSignalInfoAnnotations
attrConstruct = undefined
attrClear = clearDBusSignalInfoAnnotations
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.annotations"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#g:attr:annotations"
})
dBusSignalInfo_annotations :: AttrLabelProxy "annotations"
dBusSignalInfo_annotations = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusSignalInfo
type instance O.AttributeList DBusSignalInfo = DBusSignalInfoAttributeList
type DBusSignalInfoAttributeList = ('[ '("refCount", DBusSignalInfoRefCountFieldInfo), '("name", DBusSignalInfoNameFieldInfo), '("args", DBusSignalInfoArgsFieldInfo), '("annotations", DBusSignalInfoAnnotationsFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_dbus_signal_info_ref" g_dbus_signal_info_ref ::
Ptr DBusSignalInfo ->
IO (Ptr DBusSignalInfo)
dBusSignalInfoRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusSignalInfo
-> m DBusSignalInfo
dBusSignalInfoRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusSignalInfo -> m DBusSignalInfo
dBusSignalInfoRef DBusSignalInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusSignalInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusSignalInfo
info
Ptr DBusSignalInfo
result <- Ptr DBusSignalInfo -> IO (Ptr DBusSignalInfo)
g_dbus_signal_info_ref Ptr DBusSignalInfo
info'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusSignalInfoRef" Ptr DBusSignalInfo
result
DBusSignalInfo
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
DBusSignalInfo) Ptr DBusSignalInfo
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusSignalInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return DBusSignalInfo
result'
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoRefMethodInfo
instance (signature ~ (m DBusSignalInfo), MonadIO m) => O.OverloadedMethod DBusSignalInfoRefMethodInfo DBusSignalInfo signature where
overloadedMethod = dBusSignalInfoRef
instance O.OverloadedMethodInfo DBusSignalInfoRefMethodInfo DBusSignalInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.dBusSignalInfoRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#v:dBusSignalInfoRef"
})
#endif
foreign import ccall "g_dbus_signal_info_unref" g_dbus_signal_info_unref ::
Ptr DBusSignalInfo ->
IO ()
dBusSignalInfoUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusSignalInfo
-> m ()
dBusSignalInfoUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusSignalInfo -> m ()
dBusSignalInfoUnref DBusSignalInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusSignalInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusSignalInfo
info
Ptr DBusSignalInfo -> IO ()
g_dbus_signal_info_unref Ptr DBusSignalInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusSignalInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusSignalInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusSignalInfoUnrefMethodInfo DBusSignalInfo signature where
overloadedMethod = dBusSignalInfoUnref
instance O.OverloadedMethodInfo DBusSignalInfoUnrefMethodInfo DBusSignalInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusSignalInfo.dBusSignalInfoUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusSignalInfo.html#v:dBusSignalInfoUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusSignalInfoMethod (t :: Symbol) (o :: *) :: * where
ResolveDBusSignalInfoMethod "ref" o = DBusSignalInfoRefMethodInfo
ResolveDBusSignalInfoMethod "unref" o = DBusSignalInfoUnrefMethodInfo
ResolveDBusSignalInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusSignalInfoMethod t DBusSignalInfo, O.OverloadedMethod info DBusSignalInfo p) => OL.IsLabel t (DBusSignalInfo -> 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 ~ ResolveDBusSignalInfoMethod t DBusSignalInfo, O.OverloadedMethod info DBusSignalInfo p, R.HasField t DBusSignalInfo p) => R.HasField t DBusSignalInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusSignalInfoMethod t DBusSignalInfo, O.OverloadedMethodInfo info DBusSignalInfo) => OL.IsLabel t (O.MethodProxy info DBusSignalInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif