{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.DBusNodeInfo
(
DBusNodeInfo(..) ,
newZeroDBusNodeInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusNodeInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DBusNodeInfoGenerateXmlMethodInfo ,
#endif
dBusNodeInfoGenerateXml ,
#if defined(ENABLE_OVERLOADING)
DBusNodeInfoLookupInterfaceMethodInfo ,
#endif
dBusNodeInfoLookupInterface ,
dBusNodeInfoNewForXml ,
#if defined(ENABLE_OVERLOADING)
DBusNodeInfoRefMethodInfo ,
#endif
dBusNodeInfoRef ,
#if defined(ENABLE_OVERLOADING)
DBusNodeInfoUnrefMethodInfo ,
#endif
dBusNodeInfoUnref ,
clearDBusNodeInfoAnnotations ,
#if defined(ENABLE_OVERLOADING)
dBusNodeInfo_annotations ,
#endif
getDBusNodeInfoAnnotations ,
setDBusNodeInfoAnnotations ,
clearDBusNodeInfoInterfaces ,
#if defined(ENABLE_OVERLOADING)
dBusNodeInfo_interfaces ,
#endif
getDBusNodeInfoInterfaces ,
setDBusNodeInfoInterfaces ,
clearDBusNodeInfoNodes ,
#if defined(ENABLE_OVERLOADING)
dBusNodeInfo_nodes ,
#endif
getDBusNodeInfoNodes ,
setDBusNodeInfoNodes ,
clearDBusNodeInfoPath ,
#if defined(ENABLE_OVERLOADING)
dBusNodeInfo_path ,
#endif
getDBusNodeInfoPath ,
setDBusNodeInfoPath ,
#if defined(ENABLE_OVERLOADING)
dBusNodeInfo_refCount ,
#endif
getDBusNodeInfoRefCount ,
setDBusNodeInfoRefCount ,
) 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 GI.GLib.Structs.String as GLib.String
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusAnnotationInfo as Gio.DBusAnnotationInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
newtype DBusNodeInfo = DBusNodeInfo (SP.ManagedPtr DBusNodeInfo)
deriving (DBusNodeInfo -> DBusNodeInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusNodeInfo -> DBusNodeInfo -> Bool
$c/= :: DBusNodeInfo -> DBusNodeInfo -> Bool
== :: DBusNodeInfo -> DBusNodeInfo -> Bool
$c== :: DBusNodeInfo -> DBusNodeInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusNodeInfo where
toManagedPtr :: DBusNodeInfo -> ManagedPtr DBusNodeInfo
toManagedPtr (DBusNodeInfo ManagedPtr DBusNodeInfo
p) = ManagedPtr DBusNodeInfo
p
foreign import ccall "g_dbus_node_info_get_type" c_g_dbus_node_info_get_type ::
IO GType
type instance O.ParentTypes DBusNodeInfo = '[]
instance O.HasParentTypes DBusNodeInfo
instance B.Types.TypedObject DBusNodeInfo where
glibType :: IO GType
glibType = IO GType
c_g_dbus_node_info_get_type
instance B.Types.GBoxed DBusNodeInfo
instance B.GValue.IsGValue (Maybe DBusNodeInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_node_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusNodeInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusNodeInfo
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusNodeInfo)
gvalueSet_ Ptr GValue
gv (P.Just DBusNodeInfo
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusNodeInfo
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusNodeInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr DBusNodeInfo
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DBusNodeInfo)
if Ptr DBusNodeInfo
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 DBusNodeInfo -> DBusNodeInfo
DBusNodeInfo Ptr DBusNodeInfo
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroDBusNodeInfo :: MonadIO m => m DBusNodeInfo
newZeroDBusNodeInfo :: forall (m :: * -> *). MonadIO m => m DBusNodeInfo
newZeroDBusNodeInfo = 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
20 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 DBusNodeInfo -> DBusNodeInfo
DBusNodeInfo
instance tag ~ 'AttrSet => Constructible DBusNodeInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DBusNodeInfo -> DBusNodeInfo)
-> [AttrOp DBusNodeInfo tag] -> m DBusNodeInfo
new ManagedPtr DBusNodeInfo -> DBusNodeInfo
_ [AttrOp DBusNodeInfo tag]
attrs = do
DBusNodeInfo
o <- forall (m :: * -> *). MonadIO m => m DBusNodeInfo
newZeroDBusNodeInfo
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DBusNodeInfo
o [AttrOp DBusNodeInfo tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return DBusNodeInfo
o
getDBusNodeInfoRefCount :: MonadIO m => DBusNodeInfo -> m Int32
getDBusNodeInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m Int32
getDBusNodeInfoRefCount DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusNodeInfo
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
setDBusNodeInfoRefCount :: MonadIO m => DBusNodeInfo -> Int32 -> m ()
setDBusNodeInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> Int32 -> m ()
setDBusNodeInfoRefCount DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoRefCountFieldInfo
instance AttrInfo DBusNodeInfoRefCountFieldInfo where
type AttrBaseTypeConstraint DBusNodeInfoRefCountFieldInfo = (~) DBusNodeInfo
type AttrAllowedOps DBusNodeInfoRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DBusNodeInfoRefCountFieldInfo = (~) Int32
type AttrTransferTypeConstraint DBusNodeInfoRefCountFieldInfo = (~)Int32
type AttrTransferType DBusNodeInfoRefCountFieldInfo = Int32
type AttrGetType DBusNodeInfoRefCountFieldInfo = Int32
type AttrLabel DBusNodeInfoRefCountFieldInfo = "ref_count"
type AttrOrigin DBusNodeInfoRefCountFieldInfo = DBusNodeInfo
attrGet = getDBusNodeInfoRefCount
attrSet = setDBusNodeInfoRefCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.refCount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#g:attr:refCount"
})
dBusNodeInfo_refCount :: AttrLabelProxy "refCount"
dBusNodeInfo_refCount = AttrLabelProxy
#endif
getDBusNodeInfoPath :: MonadIO m => DBusNodeInfo -> m (Maybe T.Text)
getDBusNodeInfoPath :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m (Maybe Text)
getDBusNodeInfoPath DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusNodeInfo
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
setDBusNodeInfoPath :: MonadIO m => DBusNodeInfo -> CString -> m ()
setDBusNodeInfoPath :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> CString -> m ()
setDBusNodeInfoPath DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CString
val :: CString)
clearDBusNodeInfoPath :: MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoPath :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoPath DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoPathFieldInfo
instance AttrInfo DBusNodeInfoPathFieldInfo where
type AttrBaseTypeConstraint DBusNodeInfoPathFieldInfo = (~) DBusNodeInfo
type AttrAllowedOps DBusNodeInfoPathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusNodeInfoPathFieldInfo = (~) CString
type AttrTransferTypeConstraint DBusNodeInfoPathFieldInfo = (~)CString
type AttrTransferType DBusNodeInfoPathFieldInfo = CString
type AttrGetType DBusNodeInfoPathFieldInfo = Maybe T.Text
type AttrLabel DBusNodeInfoPathFieldInfo = "path"
type AttrOrigin DBusNodeInfoPathFieldInfo = DBusNodeInfo
attrGet = getDBusNodeInfoPath
attrSet = setDBusNodeInfoPath
attrConstruct = undefined
attrClear = clearDBusNodeInfoPath
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.path"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#g:attr:path"
})
dBusNodeInfo_path :: AttrLabelProxy "path"
dBusNodeInfo_path = AttrLabelProxy
#endif
getDBusNodeInfoInterfaces :: MonadIO m => DBusNodeInfo -> m (Maybe [Gio.DBusInterfaceInfo.DBusInterfaceInfo])
getDBusNodeInfoInterfaces :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> m (Maybe [DBusInterfaceInfo])
getDBusNodeInfoInterfaces DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
Ptr (Ptr DBusInterfaceInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
Maybe [DBusInterfaceInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusInterfaceInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusInterfaceInfo)
val' -> do
[Ptr DBusInterfaceInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusInterfaceInfo)
val'
[DBusInterfaceInfo]
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 DBusInterfaceInfo -> DBusInterfaceInfo
Gio.DBusInterfaceInfo.DBusInterfaceInfo) [Ptr DBusInterfaceInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusInterfaceInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusInterfaceInfo]
result
setDBusNodeInfoInterfaces :: MonadIO m => DBusNodeInfo -> Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo) -> m ()
setDBusNodeInfoInterfaces :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> Ptr (Ptr DBusInterfaceInfo) -> m ()
setDBusNodeInfoInterfaces DBusNodeInfo
s Ptr (Ptr DBusInterfaceInfo)
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr (Ptr DBusInterfaceInfo)
val :: Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
clearDBusNodeInfoInterfaces :: MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoInterfaces :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoInterfaces DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoInterfacesFieldInfo
instance AttrInfo DBusNodeInfoInterfacesFieldInfo where
type AttrBaseTypeConstraint DBusNodeInfoInterfacesFieldInfo = (~) DBusNodeInfo
type AttrAllowedOps DBusNodeInfoInterfacesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusNodeInfoInterfacesFieldInfo = (~) (Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
type AttrTransferTypeConstraint DBusNodeInfoInterfacesFieldInfo = (~)(Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
type AttrTransferType DBusNodeInfoInterfacesFieldInfo = (Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))
type AttrGetType DBusNodeInfoInterfacesFieldInfo = Maybe [Gio.DBusInterfaceInfo.DBusInterfaceInfo]
type AttrLabel DBusNodeInfoInterfacesFieldInfo = "interfaces"
type AttrOrigin DBusNodeInfoInterfacesFieldInfo = DBusNodeInfo
attrGet = getDBusNodeInfoInterfaces
attrSet = setDBusNodeInfoInterfaces
attrConstruct = undefined
attrClear = clearDBusNodeInfoInterfaces
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.interfaces"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#g:attr:interfaces"
})
dBusNodeInfo_interfaces :: AttrLabelProxy "interfaces"
dBusNodeInfo_interfaces = AttrLabelProxy
#endif
getDBusNodeInfoNodes :: MonadIO m => DBusNodeInfo -> m (Maybe [DBusNodeInfo])
getDBusNodeInfoNodes :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> m (Maybe [DBusNodeInfo])
getDBusNodeInfoNodes DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
Ptr (Ptr DBusNodeInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr (Ptr DBusNodeInfo))
Maybe [DBusNodeInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusNodeInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusNodeInfo)
val' -> do
[Ptr DBusNodeInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusNodeInfo)
val'
[DBusNodeInfo]
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 DBusNodeInfo -> DBusNodeInfo
DBusNodeInfo) [Ptr DBusNodeInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusNodeInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusNodeInfo]
result
setDBusNodeInfoNodes :: MonadIO m => DBusNodeInfo -> Ptr (Ptr DBusNodeInfo) -> m ()
setDBusNodeInfoNodes :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> Ptr (Ptr DBusNodeInfo) -> m ()
setDBusNodeInfoNodes DBusNodeInfo
s Ptr (Ptr DBusNodeInfo)
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr (Ptr DBusNodeInfo)
val :: Ptr (Ptr DBusNodeInfo))
clearDBusNodeInfoNodes :: MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoNodes :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoNodes DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr DBusNodeInfo))
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoNodesFieldInfo
instance AttrInfo DBusNodeInfoNodesFieldInfo where
type AttrBaseTypeConstraint DBusNodeInfoNodesFieldInfo = (~) DBusNodeInfo
type AttrAllowedOps DBusNodeInfoNodesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusNodeInfoNodesFieldInfo = (~) (Ptr (Ptr DBusNodeInfo))
type AttrTransferTypeConstraint DBusNodeInfoNodesFieldInfo = (~)(Ptr (Ptr DBusNodeInfo))
type AttrTransferType DBusNodeInfoNodesFieldInfo = (Ptr (Ptr DBusNodeInfo))
type AttrGetType DBusNodeInfoNodesFieldInfo = Maybe [DBusNodeInfo]
type AttrLabel DBusNodeInfoNodesFieldInfo = "nodes"
type AttrOrigin DBusNodeInfoNodesFieldInfo = DBusNodeInfo
attrGet = getDBusNodeInfoNodes
attrSet = setDBusNodeInfoNodes
attrConstruct = undefined
attrClear = clearDBusNodeInfoNodes
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.nodes"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#g:attr:nodes"
})
dBusNodeInfo_nodes :: AttrLabelProxy "nodes"
dBusNodeInfo_nodes = AttrLabelProxy
#endif
getDBusNodeInfoAnnotations :: MonadIO m => DBusNodeInfo -> m (Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo])
getDBusNodeInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> m (Maybe [DBusAnnotationInfo])
getDBusNodeInfoAnnotations DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
Ptr (Ptr DBusAnnotationInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: 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
setDBusNodeInfoAnnotations :: MonadIO m => DBusNodeInfo -> Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo) -> m ()
setDBusNodeInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusNodeInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusNodeInfoAnnotations DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr (Ptr DBusAnnotationInfo)
val :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
clearDBusNodeInfoAnnotations :: MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoAnnotations :: forall (m :: * -> *). MonadIO m => DBusNodeInfo -> m ()
clearDBusNodeInfoAnnotations DBusNodeInfo
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 DBusNodeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusNodeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusNodeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoAnnotationsFieldInfo
instance AttrInfo DBusNodeInfoAnnotationsFieldInfo where
type AttrBaseTypeConstraint DBusNodeInfoAnnotationsFieldInfo = (~) DBusNodeInfo
type AttrAllowedOps DBusNodeInfoAnnotationsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusNodeInfoAnnotationsFieldInfo = (~) (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferTypeConstraint DBusNodeInfoAnnotationsFieldInfo = (~)(Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferType DBusNodeInfoAnnotationsFieldInfo = (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrGetType DBusNodeInfoAnnotationsFieldInfo = Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo]
type AttrLabel DBusNodeInfoAnnotationsFieldInfo = "annotations"
type AttrOrigin DBusNodeInfoAnnotationsFieldInfo = DBusNodeInfo
attrGet = getDBusNodeInfoAnnotations
attrSet = setDBusNodeInfoAnnotations
attrConstruct = undefined
attrClear = clearDBusNodeInfoAnnotations
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.annotations"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#g:attr:annotations"
})
dBusNodeInfo_annotations :: AttrLabelProxy "annotations"
dBusNodeInfo_annotations = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusNodeInfo
type instance O.AttributeList DBusNodeInfo = DBusNodeInfoAttributeList
type DBusNodeInfoAttributeList = ('[ '("refCount", DBusNodeInfoRefCountFieldInfo), '("path", DBusNodeInfoPathFieldInfo), '("interfaces", DBusNodeInfoInterfacesFieldInfo), '("nodes", DBusNodeInfoNodesFieldInfo), '("annotations", DBusNodeInfoAnnotationsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_dbus_node_info_new_for_xml" g_dbus_node_info_new_for_xml ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr DBusNodeInfo)
dBusNodeInfoNewForXml ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m DBusNodeInfo
dBusNodeInfoNewForXml :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m DBusNodeInfo
dBusNodeInfoNewForXml Text
xmlData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
xmlData' <- Text -> IO CString
textToCString Text
xmlData
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DBusNodeInfo
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr DBusNodeInfo)
g_dbus_node_info_new_for_xml CString
xmlData'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusNodeInfoNewForXml" Ptr DBusNodeInfo
result
DBusNodeInfo
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusNodeInfo -> DBusNodeInfo
DBusNodeInfo) Ptr DBusNodeInfo
result
forall a. Ptr a -> IO ()
freeMem CString
xmlData'
forall (m :: * -> *) a. Monad m => a -> m a
return DBusNodeInfo
result'
) (do
forall a. Ptr a -> IO ()
freeMem CString
xmlData'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_dbus_node_info_generate_xml" g_dbus_node_info_generate_xml ::
Ptr DBusNodeInfo ->
Word32 ->
Ptr GLib.String.String ->
IO ()
dBusNodeInfoGenerateXml ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusNodeInfo
-> Word32
-> GLib.String.String
-> m ()
dBusNodeInfoGenerateXml :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusNodeInfo -> Word32 -> String -> m ()
dBusNodeInfoGenerateXml DBusNodeInfo
info Word32
indent String
stringBuilder = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusNodeInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusNodeInfo
info
Ptr String
stringBuilder' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
stringBuilder
Ptr DBusNodeInfo -> Word32 -> Ptr String -> IO ()
g_dbus_node_info_generate_xml Ptr DBusNodeInfo
info' Word32
indent Ptr String
stringBuilder'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusNodeInfo
info
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
stringBuilder
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoGenerateXmlMethodInfo
instance (signature ~ (Word32 -> GLib.String.String -> m ()), MonadIO m) => O.OverloadedMethod DBusNodeInfoGenerateXmlMethodInfo DBusNodeInfo signature where
overloadedMethod = dBusNodeInfoGenerateXml
instance O.OverloadedMethodInfo DBusNodeInfoGenerateXmlMethodInfo DBusNodeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.dBusNodeInfoGenerateXml",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#v:dBusNodeInfoGenerateXml"
})
#endif
foreign import ccall "g_dbus_node_info_lookup_interface" g_dbus_node_info_lookup_interface ::
Ptr DBusNodeInfo ->
CString ->
IO (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo)
dBusNodeInfoLookupInterface ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusNodeInfo
-> T.Text
-> m (Maybe Gio.DBusInterfaceInfo.DBusInterfaceInfo)
dBusNodeInfoLookupInterface :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusNodeInfo -> Text -> m (Maybe DBusInterfaceInfo)
dBusNodeInfoLookupInterface DBusNodeInfo
info Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusNodeInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusNodeInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DBusInterfaceInfo
result <- Ptr DBusNodeInfo -> CString -> IO (Ptr DBusInterfaceInfo)
g_dbus_node_info_lookup_interface Ptr DBusNodeInfo
info' CString
name'
Maybe DBusInterfaceInfo
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DBusInterfaceInfo
result forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
result' -> do
DBusInterfaceInfo
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
Gio.DBusInterfaceInfo.DBusInterfaceInfo) Ptr DBusInterfaceInfo
result'
forall (m :: * -> *) a. Monad m => a -> m a
return DBusInterfaceInfo
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusNodeInfo
info
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DBusInterfaceInfo
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoLookupInterfaceMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.DBusInterfaceInfo.DBusInterfaceInfo)), MonadIO m) => O.OverloadedMethod DBusNodeInfoLookupInterfaceMethodInfo DBusNodeInfo signature where
overloadedMethod = dBusNodeInfoLookupInterface
instance O.OverloadedMethodInfo DBusNodeInfoLookupInterfaceMethodInfo DBusNodeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.dBusNodeInfoLookupInterface",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#v:dBusNodeInfoLookupInterface"
})
#endif
foreign import ccall "g_dbus_node_info_ref" g_dbus_node_info_ref ::
Ptr DBusNodeInfo ->
IO (Ptr DBusNodeInfo)
dBusNodeInfoRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusNodeInfo
-> m DBusNodeInfo
dBusNodeInfoRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusNodeInfo -> m DBusNodeInfo
dBusNodeInfoRef DBusNodeInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusNodeInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusNodeInfo
info
Ptr DBusNodeInfo
result <- Ptr DBusNodeInfo -> IO (Ptr DBusNodeInfo)
g_dbus_node_info_ref Ptr DBusNodeInfo
info'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusNodeInfoRef" Ptr DBusNodeInfo
result
DBusNodeInfo
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusNodeInfo -> DBusNodeInfo
DBusNodeInfo) Ptr DBusNodeInfo
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusNodeInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return DBusNodeInfo
result'
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoRefMethodInfo
instance (signature ~ (m DBusNodeInfo), MonadIO m) => O.OverloadedMethod DBusNodeInfoRefMethodInfo DBusNodeInfo signature where
overloadedMethod = dBusNodeInfoRef
instance O.OverloadedMethodInfo DBusNodeInfoRefMethodInfo DBusNodeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.dBusNodeInfoRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#v:dBusNodeInfoRef"
})
#endif
foreign import ccall "g_dbus_node_info_unref" g_dbus_node_info_unref ::
Ptr DBusNodeInfo ->
IO ()
dBusNodeInfoUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusNodeInfo
-> m ()
dBusNodeInfoUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusNodeInfo -> m ()
dBusNodeInfoUnref DBusNodeInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusNodeInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusNodeInfo
info
Ptr DBusNodeInfo -> IO ()
g_dbus_node_info_unref Ptr DBusNodeInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusNodeInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusNodeInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusNodeInfoUnrefMethodInfo DBusNodeInfo signature where
overloadedMethod = dBusNodeInfoUnref
instance O.OverloadedMethodInfo DBusNodeInfoUnrefMethodInfo DBusNodeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusNodeInfo.dBusNodeInfoUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusNodeInfo.html#v:dBusNodeInfoUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusNodeInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDBusNodeInfoMethod "generateXml" o = DBusNodeInfoGenerateXmlMethodInfo
ResolveDBusNodeInfoMethod "lookupInterface" o = DBusNodeInfoLookupInterfaceMethodInfo
ResolveDBusNodeInfoMethod "ref" o = DBusNodeInfoRefMethodInfo
ResolveDBusNodeInfoMethod "unref" o = DBusNodeInfoUnrefMethodInfo
ResolveDBusNodeInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusNodeInfoMethod t DBusNodeInfo, O.OverloadedMethod info DBusNodeInfo p) => OL.IsLabel t (DBusNodeInfo -> 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 ~ ResolveDBusNodeInfoMethod t DBusNodeInfo, O.OverloadedMethod info DBusNodeInfo p, R.HasField t DBusNodeInfo p) => R.HasField t DBusNodeInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusNodeInfoMethod t DBusNodeInfo, O.OverloadedMethodInfo info DBusNodeInfo) => OL.IsLabel t (O.MethodProxy info DBusNodeInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif