{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.DBusAnnotationInfo
(
DBusAnnotationInfo(..) ,
newZeroDBusAnnotationInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusAnnotationInfoMethod ,
#endif
dBusAnnotationInfoLookup ,
#if defined(ENABLE_OVERLOADING)
DBusAnnotationInfoRefMethodInfo ,
#endif
dBusAnnotationInfoRef ,
#if defined(ENABLE_OVERLOADING)
DBusAnnotationInfoUnrefMethodInfo ,
#endif
dBusAnnotationInfoUnref ,
clearDBusAnnotationInfoAnnotations ,
#if defined(ENABLE_OVERLOADING)
dBusAnnotationInfo_annotations ,
#endif
getDBusAnnotationInfoAnnotations ,
setDBusAnnotationInfoAnnotations ,
clearDBusAnnotationInfoKey ,
#if defined(ENABLE_OVERLOADING)
dBusAnnotationInfo_key ,
#endif
getDBusAnnotationInfoKey ,
setDBusAnnotationInfoKey ,
#if defined(ENABLE_OVERLOADING)
dBusAnnotationInfo_refCount ,
#endif
getDBusAnnotationInfoRefCount ,
setDBusAnnotationInfoRefCount ,
clearDBusAnnotationInfoValue ,
#if defined(ENABLE_OVERLOADING)
dBusAnnotationInfo_value ,
#endif
getDBusAnnotationInfoValue ,
setDBusAnnotationInfoValue ,
) 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
newtype DBusAnnotationInfo = DBusAnnotationInfo (SP.ManagedPtr DBusAnnotationInfo)
deriving (DBusAnnotationInfo -> DBusAnnotationInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusAnnotationInfo -> DBusAnnotationInfo -> Bool
$c/= :: DBusAnnotationInfo -> DBusAnnotationInfo -> Bool
== :: DBusAnnotationInfo -> DBusAnnotationInfo -> Bool
$c== :: DBusAnnotationInfo -> DBusAnnotationInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusAnnotationInfo where
toManagedPtr :: DBusAnnotationInfo -> ManagedPtr DBusAnnotationInfo
toManagedPtr (DBusAnnotationInfo ManagedPtr DBusAnnotationInfo
p) = ManagedPtr DBusAnnotationInfo
p
foreign import ccall "g_dbus_annotation_info_get_type" c_g_dbus_annotation_info_get_type ::
IO GType
type instance O.ParentTypes DBusAnnotationInfo = '[]
instance O.HasParentTypes DBusAnnotationInfo
instance B.Types.TypedObject DBusAnnotationInfo where
glibType :: IO GType
glibType = IO GType
c_g_dbus_annotation_info_get_type
instance B.Types.GBoxed DBusAnnotationInfo
instance B.GValue.IsGValue (Maybe DBusAnnotationInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_annotation_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusAnnotationInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusAnnotationInfo
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusAnnotationInfo)
gvalueSet_ Ptr GValue
gv (P.Just DBusAnnotationInfo
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusAnnotationInfo
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusAnnotationInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr DBusAnnotationInfo
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DBusAnnotationInfo)
if Ptr DBusAnnotationInfo
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 DBusAnnotationInfo -> DBusAnnotationInfo
DBusAnnotationInfo Ptr DBusAnnotationInfo
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroDBusAnnotationInfo :: MonadIO m => m DBusAnnotationInfo
newZeroDBusAnnotationInfo :: forall (m :: * -> *). MonadIO m => m DBusAnnotationInfo
newZeroDBusAnnotationInfo = 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
32 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 DBusAnnotationInfo -> DBusAnnotationInfo
DBusAnnotationInfo
instance tag ~ 'AttrSet => Constructible DBusAnnotationInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo)
-> [AttrOp DBusAnnotationInfo tag] -> m DBusAnnotationInfo
new ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo
_ [AttrOp DBusAnnotationInfo tag]
attrs = do
DBusAnnotationInfo
o <- forall (m :: * -> *). MonadIO m => m DBusAnnotationInfo
newZeroDBusAnnotationInfo
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DBusAnnotationInfo
o [AttrOp DBusAnnotationInfo tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return DBusAnnotationInfo
o
getDBusAnnotationInfoRefCount :: MonadIO m => DBusAnnotationInfo -> m Int32
getDBusAnnotationInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusAnnotationInfo -> m Int32
getDBusAnnotationInfoRefCount DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusAnnotationInfo
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
setDBusAnnotationInfoRefCount :: MonadIO m => DBusAnnotationInfo -> Int32 -> m ()
setDBusAnnotationInfoRefCount :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> Int32 -> m ()
setDBusAnnotationInfoRefCount DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoRefCountFieldInfo
instance AttrInfo DBusAnnotationInfoRefCountFieldInfo where
type AttrBaseTypeConstraint DBusAnnotationInfoRefCountFieldInfo = (~) DBusAnnotationInfo
type AttrAllowedOps DBusAnnotationInfoRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DBusAnnotationInfoRefCountFieldInfo = (~) Int32
type AttrTransferTypeConstraint DBusAnnotationInfoRefCountFieldInfo = (~)Int32
type AttrTransferType DBusAnnotationInfoRefCountFieldInfo = Int32
type AttrGetType DBusAnnotationInfoRefCountFieldInfo = Int32
type AttrLabel DBusAnnotationInfoRefCountFieldInfo = "ref_count"
type AttrOrigin DBusAnnotationInfoRefCountFieldInfo = DBusAnnotationInfo
attrGet = getDBusAnnotationInfoRefCount
attrSet = setDBusAnnotationInfoRefCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.refCount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#g:attr:refCount"
})
dBusAnnotationInfo_refCount :: AttrLabelProxy "refCount"
dBusAnnotationInfo_refCount = AttrLabelProxy
#endif
getDBusAnnotationInfoKey :: MonadIO m => DBusAnnotationInfo -> m (Maybe T.Text)
getDBusAnnotationInfoKey :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> m (Maybe Text)
getDBusAnnotationInfoKey DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: 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
setDBusAnnotationInfoKey :: MonadIO m => DBusAnnotationInfo -> CString -> m ()
setDBusAnnotationInfoKey :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> CString -> m ()
setDBusAnnotationInfoKey DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
val :: CString)
clearDBusAnnotationInfoKey :: MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoKey :: forall (m :: * -> *). MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoKey DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoKeyFieldInfo
instance AttrInfo DBusAnnotationInfoKeyFieldInfo where
type AttrBaseTypeConstraint DBusAnnotationInfoKeyFieldInfo = (~) DBusAnnotationInfo
type AttrAllowedOps DBusAnnotationInfoKeyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusAnnotationInfoKeyFieldInfo = (~) CString
type AttrTransferTypeConstraint DBusAnnotationInfoKeyFieldInfo = (~)CString
type AttrTransferType DBusAnnotationInfoKeyFieldInfo = CString
type AttrGetType DBusAnnotationInfoKeyFieldInfo = Maybe T.Text
type AttrLabel DBusAnnotationInfoKeyFieldInfo = "key"
type AttrOrigin DBusAnnotationInfoKeyFieldInfo = DBusAnnotationInfo
attrGet = getDBusAnnotationInfoKey
attrSet = setDBusAnnotationInfoKey
attrConstruct = undefined
attrClear = clearDBusAnnotationInfoKey
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.key"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#g:attr:key"
})
dBusAnnotationInfo_key :: AttrLabelProxy "key"
dBusAnnotationInfo_key = AttrLabelProxy
#endif
getDBusAnnotationInfoValue :: MonadIO m => DBusAnnotationInfo -> m (Maybe T.Text)
getDBusAnnotationInfoValue :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> m (Maybe Text)
getDBusAnnotationInfoValue DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: 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
setDBusAnnotationInfoValue :: MonadIO m => DBusAnnotationInfo -> CString -> m ()
setDBusAnnotationInfoValue :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> CString -> m ()
setDBusAnnotationInfoValue DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)
clearDBusAnnotationInfoValue :: MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoValue :: forall (m :: * -> *). MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoValue DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoValueFieldInfo
instance AttrInfo DBusAnnotationInfoValueFieldInfo where
type AttrBaseTypeConstraint DBusAnnotationInfoValueFieldInfo = (~) DBusAnnotationInfo
type AttrAllowedOps DBusAnnotationInfoValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusAnnotationInfoValueFieldInfo = (~) CString
type AttrTransferTypeConstraint DBusAnnotationInfoValueFieldInfo = (~)CString
type AttrTransferType DBusAnnotationInfoValueFieldInfo = CString
type AttrGetType DBusAnnotationInfoValueFieldInfo = Maybe T.Text
type AttrLabel DBusAnnotationInfoValueFieldInfo = "value"
type AttrOrigin DBusAnnotationInfoValueFieldInfo = DBusAnnotationInfo
attrGet = getDBusAnnotationInfoValue
attrSet = setDBusAnnotationInfoValue
attrConstruct = undefined
attrClear = clearDBusAnnotationInfoValue
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.value"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#g:attr:value"
})
dBusAnnotationInfo_value :: AttrLabelProxy "value"
dBusAnnotationInfo_value = AttrLabelProxy
#endif
getDBusAnnotationInfoAnnotations :: MonadIO m => DBusAnnotationInfo -> m (Maybe [DBusAnnotationInfo])
getDBusAnnotationInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> m (Maybe [DBusAnnotationInfo])
getDBusAnnotationInfoAnnotations DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
Ptr (Ptr DBusAnnotationInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr (Ptr 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
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
setDBusAnnotationInfoAnnotations :: MonadIO m => DBusAnnotationInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusAnnotationInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusAnnotationInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusAnnotationInfoAnnotations DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr (Ptr DBusAnnotationInfo)
val :: Ptr (Ptr DBusAnnotationInfo))
clearDBusAnnotationInfoAnnotations :: MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoAnnotations :: forall (m :: * -> *). MonadIO m => DBusAnnotationInfo -> m ()
clearDBusAnnotationInfoAnnotations DBusAnnotationInfo
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 DBusAnnotationInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusAnnotationInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusAnnotationInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr DBusAnnotationInfo))
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoAnnotationsFieldInfo
instance AttrInfo DBusAnnotationInfoAnnotationsFieldInfo where
type AttrBaseTypeConstraint DBusAnnotationInfoAnnotationsFieldInfo = (~) DBusAnnotationInfo
type AttrAllowedOps DBusAnnotationInfoAnnotationsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusAnnotationInfoAnnotationsFieldInfo = (~) (Ptr (Ptr DBusAnnotationInfo))
type AttrTransferTypeConstraint DBusAnnotationInfoAnnotationsFieldInfo = (~)(Ptr (Ptr DBusAnnotationInfo))
type AttrTransferType DBusAnnotationInfoAnnotationsFieldInfo = (Ptr (Ptr DBusAnnotationInfo))
type AttrGetType DBusAnnotationInfoAnnotationsFieldInfo = Maybe [DBusAnnotationInfo]
type AttrLabel DBusAnnotationInfoAnnotationsFieldInfo = "annotations"
type AttrOrigin DBusAnnotationInfoAnnotationsFieldInfo = DBusAnnotationInfo
attrGet = getDBusAnnotationInfoAnnotations
attrSet = setDBusAnnotationInfoAnnotations
attrConstruct = undefined
attrClear = clearDBusAnnotationInfoAnnotations
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.annotations"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#g:attr:annotations"
})
dBusAnnotationInfo_annotations :: AttrLabelProxy "annotations"
dBusAnnotationInfo_annotations = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusAnnotationInfo
type instance O.AttributeList DBusAnnotationInfo = DBusAnnotationInfoAttributeList
type DBusAnnotationInfoAttributeList = ('[ '("refCount", DBusAnnotationInfoRefCountFieldInfo), '("key", DBusAnnotationInfoKeyFieldInfo), '("value", DBusAnnotationInfoValueFieldInfo), '("annotations", DBusAnnotationInfoAnnotationsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_dbus_annotation_info_ref" g_dbus_annotation_info_ref ::
Ptr DBusAnnotationInfo ->
IO (Ptr DBusAnnotationInfo)
dBusAnnotationInfoRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusAnnotationInfo
-> m DBusAnnotationInfo
dBusAnnotationInfoRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusAnnotationInfo -> m DBusAnnotationInfo
dBusAnnotationInfoRef DBusAnnotationInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusAnnotationInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusAnnotationInfo
info
Ptr DBusAnnotationInfo
result <- Ptr DBusAnnotationInfo -> IO (Ptr DBusAnnotationInfo)
g_dbus_annotation_info_ref Ptr DBusAnnotationInfo
info'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusAnnotationInfoRef" Ptr DBusAnnotationInfo
result
DBusAnnotationInfo
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo
DBusAnnotationInfo) Ptr DBusAnnotationInfo
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusAnnotationInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return DBusAnnotationInfo
result'
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoRefMethodInfo
instance (signature ~ (m DBusAnnotationInfo), MonadIO m) => O.OverloadedMethod DBusAnnotationInfoRefMethodInfo DBusAnnotationInfo signature where
overloadedMethod = dBusAnnotationInfoRef
instance O.OverloadedMethodInfo DBusAnnotationInfoRefMethodInfo DBusAnnotationInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.dBusAnnotationInfoRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#v:dBusAnnotationInfoRef"
})
#endif
foreign import ccall "g_dbus_annotation_info_unref" g_dbus_annotation_info_unref ::
Ptr DBusAnnotationInfo ->
IO ()
dBusAnnotationInfoUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusAnnotationInfo
-> m ()
dBusAnnotationInfoUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusAnnotationInfo -> m ()
dBusAnnotationInfoUnref DBusAnnotationInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusAnnotationInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusAnnotationInfo
info
Ptr DBusAnnotationInfo -> IO ()
g_dbus_annotation_info_unref Ptr DBusAnnotationInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusAnnotationInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusAnnotationInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusAnnotationInfoUnrefMethodInfo DBusAnnotationInfo signature where
overloadedMethod = dBusAnnotationInfoUnref
instance O.OverloadedMethodInfo DBusAnnotationInfoUnrefMethodInfo DBusAnnotationInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusAnnotationInfo.dBusAnnotationInfoUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusAnnotationInfo.html#v:dBusAnnotationInfoUnref"
})
#endif
foreign import ccall "g_dbus_annotation_info_lookup" g_dbus_annotation_info_lookup ::
Ptr (Ptr DBusAnnotationInfo) ->
CString ->
IO CString
dBusAnnotationInfoLookup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe ([DBusAnnotationInfo])
-> T.Text
-> m (Maybe T.Text)
dBusAnnotationInfoLookup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe [DBusAnnotationInfo] -> Text -> m (Maybe Text)
dBusAnnotationInfoLookup Maybe [DBusAnnotationInfo]
annotations Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr (Ptr DBusAnnotationInfo)
maybeAnnotations <- case Maybe [DBusAnnotationInfo]
annotations of
Maybe [DBusAnnotationInfo]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just [DBusAnnotationInfo]
jAnnotations -> do
[Ptr DBusAnnotationInfo]
jAnnotations' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [DBusAnnotationInfo]
jAnnotations
Ptr (Ptr DBusAnnotationInfo)
jAnnotations'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr DBusAnnotationInfo]
jAnnotations'
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr DBusAnnotationInfo)
jAnnotations''
CString
name' <- Text -> IO CString
textToCString Text
name
CString
result <- Ptr (Ptr DBusAnnotationInfo) -> CString -> IO CString
g_dbus_annotation_info_lookup Ptr (Ptr DBusAnnotationInfo)
maybeAnnotations CString
name'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [DBusAnnotationInfo]
annotations (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr DBusAnnotationInfo)
maybeAnnotations
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusAnnotationInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDBusAnnotationInfoMethod "ref" o = DBusAnnotationInfoRefMethodInfo
ResolveDBusAnnotationInfoMethod "unref" o = DBusAnnotationInfoUnrefMethodInfo
ResolveDBusAnnotationInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusAnnotationInfoMethod t DBusAnnotationInfo, O.OverloadedMethod info DBusAnnotationInfo p) => OL.IsLabel t (DBusAnnotationInfo -> 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 ~ ResolveDBusAnnotationInfoMethod t DBusAnnotationInfo, O.OverloadedMethod info DBusAnnotationInfo p, R.HasField t DBusAnnotationInfo p) => R.HasField t DBusAnnotationInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusAnnotationInfoMethod t DBusAnnotationInfo, O.OverloadedMethodInfo info DBusAnnotationInfo) => OL.IsLabel t (O.MethodProxy info DBusAnnotationInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif