Data.GI.Base.Utils

Assorted utility functions for bindings.

Documentation

whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()

When the given value is of "Just a" form, execute the given action, otherwise do nothing.

maybeM :: Monad m => b -> Maybe a -> (a -> m b) -> m b

Like maybe, but for actions on a monad, and with slightly different argument order.

maybeFromPtr :: Ptr a -> Maybe (Ptr a)

Check if the pointer is nullPtr, and wrap it on a Maybe accordingly.

mapFirst :: (a -> c) -> [(a, b)] -> [(c, b)]

Given a function and a list of two-tuples, apply the function to every first element of the tuples.

mapFirstA :: Applicative f => (a -> f c) -> [(a, b)] -> f [(c, b)]

Applicative version of mapFirst.

mapSecond :: (b -> c) -> [(a, b)] -> [(a, c)]

Same for the second element.

mapSecondA :: Applicative f => (b -> f c) -> [(a, b)] -> f [(a, c)]

Applicative version of mapSecond.

convertIfNonNull :: Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)

Apply the given conversion action to the given pointer if it is non-NULL, otherwise return Nothing.

convertFunPtrIfNonNull :: FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)

Apply the given conversion action to the given function pointer if it is non-NULL, otherwise return Nothing.

callocBytes :: Int -> IO (Ptr a)

Make a zero-filled allocation using the GLib allocator.

callocBoxedBytes :: forall a. GBoxed a => Int -> IO (Ptr a)

Make a zero filled allocation of n bytes for a boxed object. The difference with a normal callocBytes is that the returned memory is allocated using whatever memory allocator g_boxed_copy uses, which in particular may well be different from a plain g_malloc. In particular g_slice_alloc is often used for allocating boxed objects, which are then freed using g_slice_free.

callocMem :: forall a. Storable a => IO (Ptr a)

Make a zero-filled allocation of enough size to hold the given Storable type, using the GLib allocator.

allocBytes :: Integral a => a -> IO (Ptr b)

Allocate the given number of bytes using the GLib allocator.

allocMem :: forall a. Storable a => IO (Ptr a)

Allocate space for the given Storable using the GLib allocator.

freeMem :: Ptr a -> IO ()

A wrapper for g_free.

ptr_to_g_free :: FunPtr (Ptr a -> IO ())

Pointer to g_free.

memcpy :: Ptr a -> Ptr b -> Int -> IO ()

Copy memory into a destination (in the first argument) from a source (in the second argument).

safeFreeFunPtr :: Ptr a -> IO ()

Same as freeHaskellFunPtr, but it does nothing when given a nullPtr.

safeFreeFunPtrPtr :: FunPtr (Ptr a -> IO ())

A pointer to safeFreeFunPtr.

safeFreeFunPtrPtr' :: FunPtr (Ptr a -> Ptr b -> IO ())

Similar to safeFreeFunPtrPtr, but accepts an additional (ignored) argument. The first argument is interpreted as a FunPtr, and released.

maybeReleaseFunPtr :: Maybe (Ptr (FunPtr a)) -> IO ()

If given a pointer to the memory location, free the FunPtr at that location, and then the pointer itself. Useful for freeing the memory associated to callbacks which are called just once, with no destroy notification.

checkUnexpectedReturnNULL :: HasCallStack => Text -> Ptr a -> IO ()

Check that the given pointer is not NULL. If it is, raise a UnexpectedNullPointerReturn exception.

checkUnexpectedNothing :: HasCallStack => Text -> IO (Maybe a) -> IO a

An annotated version of fromJust, which raises a UnexpectedNullPointerReturn in case it encounters a Nothing.

dbgLog :: Text -> IO ()

Print a string to the debug log in an atomic way (so the output of different threads does not get intermingled).