{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.UnixFDMessage
(
UnixFDMessage(..) ,
IsUnixFDMessage ,
toUnixFDMessage ,
#if defined(ENABLE_OVERLOADING)
ResolveUnixFDMessageMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UnixFDMessageAppendFdMethodInfo ,
#endif
unixFDMessageAppendFd ,
#if defined(ENABLE_OVERLOADING)
UnixFDMessageGetFdListMethodInfo ,
#endif
unixFDMessageGetFdList ,
unixFDMessageNew ,
unixFDMessageNewWithFdList ,
#if defined(ENABLE_OVERLOADING)
UnixFDMessageStealFdsMethodInfo ,
#endif
unixFDMessageStealFds ,
#if defined(ENABLE_OVERLOADING)
UnixFDMessageFdListPropertyInfo ,
#endif
constructUnixFDMessageFdList ,
getUnixFDMessageFdList ,
#if defined(ENABLE_OVERLOADING)
unixFDMessageFdList ,
#endif
) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketControlMessage as Gio.SocketControlMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
newtype UnixFDMessage = UnixFDMessage (SP.ManagedPtr UnixFDMessage)
deriving (UnixFDMessage -> UnixFDMessage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnixFDMessage -> UnixFDMessage -> Bool
$c/= :: UnixFDMessage -> UnixFDMessage -> Bool
== :: UnixFDMessage -> UnixFDMessage -> Bool
$c== :: UnixFDMessage -> UnixFDMessage -> Bool
Eq)
instance SP.ManagedPtrNewtype UnixFDMessage where
toManagedPtr :: UnixFDMessage -> ManagedPtr UnixFDMessage
toManagedPtr (UnixFDMessage ManagedPtr UnixFDMessage
p) = ManagedPtr UnixFDMessage
p
foreign import ccall "g_unix_fd_message_get_type"
c_g_unix_fd_message_get_type :: IO B.Types.GType
instance B.Types.TypedObject UnixFDMessage where
glibType :: IO GType
glibType = IO GType
c_g_unix_fd_message_get_type
instance B.Types.GObject UnixFDMessage
class (SP.GObject o, O.IsDescendantOf UnixFDMessage o) => IsUnixFDMessage o
instance (SP.GObject o, O.IsDescendantOf UnixFDMessage o) => IsUnixFDMessage o
instance O.HasParentTypes UnixFDMessage
type instance O.ParentTypes UnixFDMessage = '[Gio.SocketControlMessage.SocketControlMessage, GObject.Object.Object]
toUnixFDMessage :: (MIO.MonadIO m, IsUnixFDMessage o) => o -> m UnixFDMessage
toUnixFDMessage :: forall (m :: * -> *) o.
(MonadIO m, IsUnixFDMessage o) =>
o -> m UnixFDMessage
toUnixFDMessage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr UnixFDMessage -> UnixFDMessage
UnixFDMessage
instance B.GValue.IsGValue (Maybe UnixFDMessage) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_unix_fd_message_get_type
gvalueSet_ :: Ptr GValue -> Maybe UnixFDMessage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UnixFDMessage
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr UnixFDMessage)
gvalueSet_ Ptr GValue
gv (P.Just UnixFDMessage
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnixFDMessage
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe UnixFDMessage)
gvalueGet_ Ptr GValue
gv = do
Ptr UnixFDMessage
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UnixFDMessage)
if Ptr UnixFDMessage
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 b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UnixFDMessage -> UnixFDMessage
UnixFDMessage Ptr UnixFDMessage
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveUnixFDMessageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveUnixFDMessageMethod "appendFd" o = UnixFDMessageAppendFdMethodInfo
ResolveUnixFDMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveUnixFDMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveUnixFDMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveUnixFDMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveUnixFDMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveUnixFDMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveUnixFDMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveUnixFDMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveUnixFDMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveUnixFDMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveUnixFDMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveUnixFDMessageMethod "serialize" o = Gio.SocketControlMessage.SocketControlMessageSerializeMethodInfo
ResolveUnixFDMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveUnixFDMessageMethod "stealFds" o = UnixFDMessageStealFdsMethodInfo
ResolveUnixFDMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveUnixFDMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveUnixFDMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveUnixFDMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveUnixFDMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveUnixFDMessageMethod "getFdList" o = UnixFDMessageGetFdListMethodInfo
ResolveUnixFDMessageMethod "getLevel" o = Gio.SocketControlMessage.SocketControlMessageGetLevelMethodInfo
ResolveUnixFDMessageMethod "getMsgType" o = Gio.SocketControlMessage.SocketControlMessageGetMsgTypeMethodInfo
ResolveUnixFDMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveUnixFDMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveUnixFDMessageMethod "getSize" o = Gio.SocketControlMessage.SocketControlMessageGetSizeMethodInfo
ResolveUnixFDMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveUnixFDMessageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveUnixFDMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveUnixFDMessageMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUnixFDMessageMethod t UnixFDMessage, O.OverloadedMethod info UnixFDMessage p) => OL.IsLabel t (UnixFDMessage -> 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 ~ ResolveUnixFDMessageMethod t UnixFDMessage, O.OverloadedMethod info UnixFDMessage p, R.HasField t UnixFDMessage p) => R.HasField t UnixFDMessage p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveUnixFDMessageMethod t UnixFDMessage, O.OverloadedMethodInfo info UnixFDMessage) => OL.IsLabel t (O.MethodProxy info UnixFDMessage) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getUnixFDMessageFdList :: (MonadIO m, IsUnixFDMessage o) => o -> m Gio.UnixFDList.UnixFDList
getUnixFDMessageFdList :: forall (m :: * -> *) o.
(MonadIO m, IsUnixFDMessage o) =>
o -> m UnixFDList
getUnixFDMessageFdList o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getUnixFDMessageFdList" forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"fd-list" ManagedPtr UnixFDList -> UnixFDList
Gio.UnixFDList.UnixFDList
constructUnixFDMessageFdList :: (IsUnixFDMessage o, MIO.MonadIO m, Gio.UnixFDList.IsUnixFDList a) => a -> m (GValueConstruct o)
constructUnixFDMessageFdList :: forall o (m :: * -> *) a.
(IsUnixFDMessage o, MonadIO m, IsUnixFDList a) =>
a -> m (GValueConstruct o)
constructUnixFDMessageFdList a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"fd-list" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data UnixFDMessageFdListPropertyInfo
instance AttrInfo UnixFDMessageFdListPropertyInfo where
type AttrAllowedOps UnixFDMessageFdListPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint UnixFDMessageFdListPropertyInfo = IsUnixFDMessage
type AttrSetTypeConstraint UnixFDMessageFdListPropertyInfo = Gio.UnixFDList.IsUnixFDList
type AttrTransferTypeConstraint UnixFDMessageFdListPropertyInfo = Gio.UnixFDList.IsUnixFDList
type AttrTransferType UnixFDMessageFdListPropertyInfo = Gio.UnixFDList.UnixFDList
type AttrGetType UnixFDMessageFdListPropertyInfo = Gio.UnixFDList.UnixFDList
type AttrLabel UnixFDMessageFdListPropertyInfo = "fd-list"
type AttrOrigin UnixFDMessageFdListPropertyInfo = UnixFDMessage
attrGet = getUnixFDMessageFdList
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gio.UnixFDList.UnixFDList v
attrConstruct = constructUnixFDMessageFdList
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixFDMessage.fdList"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixFDMessage.html#g:attr:fdList"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UnixFDMessage
type instance O.AttributeList UnixFDMessage = UnixFDMessageAttributeList
type UnixFDMessageAttributeList = ('[ '("fdList", UnixFDMessageFdListPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
unixFDMessageFdList :: AttrLabelProxy "fdList"
unixFDMessageFdList = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UnixFDMessage = UnixFDMessageSignalList
type UnixFDMessageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_unix_fd_message_new" g_unix_fd_message_new ::
IO (Ptr UnixFDMessage)
unixFDMessageNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m UnixFDMessage
unixFDMessageNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m UnixFDMessage
unixFDMessageNew = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixFDMessage
result <- IO (Ptr UnixFDMessage)
g_unix_fd_message_new
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unixFDMessageNew" Ptr UnixFDMessage
result
UnixFDMessage
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnixFDMessage -> UnixFDMessage
UnixFDMessage) Ptr UnixFDMessage
result
forall (m :: * -> *) a. Monad m => a -> m a
return UnixFDMessage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_unix_fd_message_new_with_fd_list" g_unix_fd_message_new_with_fd_list ::
Ptr Gio.UnixFDList.UnixFDList ->
IO (Ptr UnixFDMessage)
unixFDMessageNewWithFdList ::
(B.CallStack.HasCallStack, MonadIO m, Gio.UnixFDList.IsUnixFDList a) =>
a
-> m UnixFDMessage
unixFDMessageNewWithFdList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixFDList a) =>
a -> m UnixFDMessage
unixFDMessageNewWithFdList a
fdList = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixFDList
fdList' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fdList
Ptr UnixFDMessage
result <- Ptr UnixFDList -> IO (Ptr UnixFDMessage)
g_unix_fd_message_new_with_fd_list Ptr UnixFDList
fdList'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unixFDMessageNewWithFdList" Ptr UnixFDMessage
result
UnixFDMessage
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnixFDMessage -> UnixFDMessage
UnixFDMessage) Ptr UnixFDMessage
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fdList
forall (m :: * -> *) a. Monad m => a -> m a
return UnixFDMessage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_unix_fd_message_append_fd" g_unix_fd_message_append_fd ::
Ptr UnixFDMessage ->
Int32 ->
Ptr (Ptr GError) ->
IO CInt
unixFDMessageAppendFd ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a
-> Int32
-> m ()
unixFDMessageAppendFd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a -> Int32 -> m ()
unixFDMessageAppendFd a
message Int32
fd = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixFDMessage
message' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr UnixFDMessage -> Int32 -> Ptr (Ptr GError) -> IO CInt
g_unix_fd_message_append_fd Ptr UnixFDMessage
message' Int32
fd
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data UnixFDMessageAppendFdMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsUnixFDMessage a) => O.OverloadedMethod UnixFDMessageAppendFdMethodInfo a signature where
overloadedMethod = unixFDMessageAppendFd
instance O.OverloadedMethodInfo UnixFDMessageAppendFdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixFDMessage.unixFDMessageAppendFd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixFDMessage.html#v:unixFDMessageAppendFd"
})
#endif
foreign import ccall "g_unix_fd_message_get_fd_list" g_unix_fd_message_get_fd_list ::
Ptr UnixFDMessage ->
IO (Ptr Gio.UnixFDList.UnixFDList)
unixFDMessageGetFdList ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a
-> m Gio.UnixFDList.UnixFDList
unixFDMessageGetFdList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a -> m UnixFDList
unixFDMessageGetFdList a
message = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixFDMessage
message' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr UnixFDList
result <- Ptr UnixFDMessage -> IO (Ptr UnixFDList)
g_unix_fd_message_get_fd_list Ptr UnixFDMessage
message'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unixFDMessageGetFdList" Ptr UnixFDList
result
UnixFDList
result' <- (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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
forall (m :: * -> *) a. Monad m => a -> m a
return UnixFDList
result'
#if defined(ENABLE_OVERLOADING)
data UnixFDMessageGetFdListMethodInfo
instance (signature ~ (m Gio.UnixFDList.UnixFDList), MonadIO m, IsUnixFDMessage a) => O.OverloadedMethod UnixFDMessageGetFdListMethodInfo a signature where
overloadedMethod = unixFDMessageGetFdList
instance O.OverloadedMethodInfo UnixFDMessageGetFdListMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixFDMessage.unixFDMessageGetFdList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixFDMessage.html#v:unixFDMessageGetFdList"
})
#endif
foreign import ccall "g_unix_fd_message_steal_fds" g_unix_fd_message_steal_fds ::
Ptr UnixFDMessage ->
Ptr Int32 ->
IO (Ptr Int32)
unixFDMessageStealFds ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a
-> m [Int32]
unixFDMessageStealFds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixFDMessage a) =>
a -> m [Int32]
unixFDMessageStealFds a
message = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixFDMessage
message' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
message
Ptr Int32
length_ <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
result <- Ptr UnixFDMessage -> Ptr Int32 -> IO (Ptr Int32)
g_unix_fd_message_steal_fds Ptr UnixFDMessage
message' Ptr Int32
length_
Int32
length_' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
length_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unixFDMessageStealFds" Ptr Int32
result
[Int32]
result' <- (forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackStorableArrayWithLength Int32
length_') Ptr Int32
result
forall a. Ptr a -> IO ()
freeMem Ptr Int32
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
message
forall a. Ptr a -> IO ()
freeMem Ptr Int32
length_
forall (m :: * -> *) a. Monad m => a -> m a
return [Int32]
result'
#if defined(ENABLE_OVERLOADING)
data UnixFDMessageStealFdsMethodInfo
instance (signature ~ (m [Int32]), MonadIO m, IsUnixFDMessage a) => O.OverloadedMethod UnixFDMessageStealFdsMethodInfo a signature where
overloadedMethod = unixFDMessageStealFds
instance O.OverloadedMethodInfo UnixFDMessageStealFdsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixFDMessage.unixFDMessageStealFds",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixFDMessage.html#v:unixFDMessageStealFds"
})
#endif