{-# LANGUAGE CPP #-}
{-# OPTIONS_HADDOCK hide #-}
module System.Glib.FFI (
nullForeignPtr,
maybeNull,
newForeignPtr,
withForeignPtrs,
#if MIN_VERSION_base(4,4,0)
unsafePerformIO,
unsafeForeignPtrToPtr,
#endif
module Foreign,
module Foreign.C
) where
import Foreign.C
#if MIN_VERSION_base(4,4,0)
import Foreign hiding (unsafePerformIO, unsafeForeignPtrToPtr, newForeignPtr, free)
import System.IO.Unsafe (unsafePerformIO)
import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
#else
import Foreign hiding (newForeignPtr, free)
#endif
import qualified Foreign.Concurrent
newForeignPtr :: Ptr a -> FinalizerPtr a -> IO (ForeignPtr a)
newForeignPtr :: forall a. Ptr a -> FinalizerPtr a -> IO (ForeignPtr a)
newForeignPtr Ptr a
p FinalizerPtr a
finalizer
= forall a. Ptr a -> IO () -> IO (ForeignPtr a)
Foreign.Concurrent.newForeignPtr Ptr a
p (forall a. FinalizerPtr a -> Ptr a -> IO ()
mkFinalizer FinalizerPtr a
finalizer Ptr a
p)
foreign import ccall "dynamic"
mkFinalizer :: FinalizerPtr a -> Ptr a -> IO ()
nullForeignPtr :: ForeignPtr a
nullForeignPtr :: forall a. ForeignPtr a
nullForeignPtr = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. Ptr a -> IO (ForeignPtr a)
newForeignPtr_ forall a. Ptr a
nullPtr
withForeignPtrs :: [ForeignPtr a] -> ([Ptr a] -> IO b) -> IO b
withForeignPtrs :: forall a b. [ForeignPtr a] -> ([Ptr a] -> IO b) -> IO b
withForeignPtrs [ForeignPtr a]
fptrs [Ptr a] -> IO b
body = do
b
result <- [Ptr a] -> IO b
body (forall a b. (a -> b) -> [a] -> [b]
map forall a. ForeignPtr a -> Ptr a
unsafeForeignPtrToPtr [ForeignPtr a]
fptrs)
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ForeignPtr a -> IO ()
touchForeignPtr [ForeignPtr a]
fptrs
forall (m :: * -> *) a. Monad m => a -> m a
return b
result
maybeNull :: (IO (Ptr a) -> IO a) -> IO (Ptr a) -> IO (Maybe a)
maybeNull :: forall a. (IO (Ptr a) -> IO a) -> IO (Ptr a) -> IO (Maybe a)
maybeNull IO (Ptr a) -> IO a
marshal IO (Ptr a)
genPtr = do
Ptr a
ptr <- IO (Ptr a)
genPtr
if Ptr a
ptr forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
else do a
result <- IO (Ptr a) -> IO a
marshal (forall (m :: * -> *) a. Monad m => a -> m a
return Ptr a
ptr)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
result)