Safe Haskell	None
Language	Haskell98

Data.GI.Base.BasicTypes

Contents

GType related
Memory management
Basic GLib / GObject types

Description

Basic types used in the bindings.

Synopsis

module Data.GI.Base.GType
data ManagedPtr a = ManagedPtr {
- managedForeignPtr :: ForeignPtr a
- managedPtrAllocCallStack :: Maybe CallStack
- managedPtrIsDisowned :: IORef (Maybe CallStack)
}
type ManagedPtrNewtype a = Coercible a (ManagedPtr ())
class ManagedPtrNewtype a => BoxedObject a where
- boxedType :: a -> IO GType
class BoxedEnum a where
- boxedEnumType :: a -> IO GType
class BoxedFlags a where
- boxedFlagsType :: Proxy a -> IO GType
class ManagedPtrNewtype a => GObject a where
- gobjectType :: a -> IO GType
class ManagedPtrNewtype a => WrappedPtr a where
- wrappedPtrCalloc :: IO (Ptr a)
- wrappedPtrCopy :: a -> IO a
- wrappedPtrFree :: Maybe (FunPtr (Ptr a -> IO ()))
data UnexpectedNullPointerReturn = UnexpectedNullPointerReturn {
- nullPtrErrorMsg :: Text
}
class NullToNothing a where
- nullToNothing :: MonadIO m => IO a -> m (Maybe (UnMaybe a))
newtype GVariant = GVariant (ManagedPtr GVariant)
newtype GParamSpec = GParamSpec (ManagedPtr GParamSpec)
data GArray a = GArray (Ptr (GArray a))
data GPtrArray a = GPtrArray (Ptr (GPtrArray a))
data GByteArray = GByteArray (Ptr GByteArray)
data GHashTable a b = GHashTable (Ptr (GHashTable a b))
data GList a = GList (Ptr (GList a))
g_list_free :: Ptr (GList a) -> IO ()
data GSList a = GSList (Ptr (GSList a))
g_slist_free :: Ptr (GSList a) -> IO ()
class Enum a => IsGFlag a
newtype PtrWrapped a = PtrWrapped {
- unwrapPtr :: Ptr a
}
type GDestroyNotify a = FunPtr (Ptr a -> IO ())

GType related

module Data.GI.Base.GType

Memory management

data ManagedPtr a Source #

Thin wrapper over ForeignPtr, supporting the extra notion of disowning, that is, not running the finalizers associated with the foreign ptr.

Constructors

ManagedPtr
Fields managedForeignPtr :: ForeignPtr a managedPtrAllocCallStack :: Maybe CallStack `CallStack` for the call that created the pointer. managedPtrIsDisowned :: IORef (Maybe CallStack) When disowned, the `CallStack` for the disowning call.

type ManagedPtrNewtype a = Coercible a (ManagedPtr ()) Source #

A constraint ensuring that the given type is coercible to a ManagedPtr. It will hold for newtypes of the form

newtype Foo = Foo (ManagedPtr Foo)

which is the typical shape of wrapped GObjects.

class ManagedPtrNewtype a => BoxedObject a where Source #

Wrapped boxed structures, identified by their GType.

Methods

boxedType :: a -> IO GType Source #

Instances

BoxedObject Closure Source #
Instance details Defined in Data.GI.Base.Closure Methods boxedType :: Closure -> IO GType Source #
BoxedObject GValue Source #
Instance details Defined in Data.GI.Base.GValue Methods boxedType :: GValue -> IO GType Source #
BoxedObject GError Source #
Instance details Defined in Data.GI.Base.GError Methods boxedType :: GError -> IO GType Source #

class BoxedEnum a where Source #

Enums with an associated GType.

Methods

boxedEnumType :: a -> IO GType Source #

class BoxedFlags a where Source #

Flags with an associated GType.

Methods

boxedFlagsType :: Proxy a -> IO GType Source #

class ManagedPtrNewtype a => GObject a where Source #

A wrapped GObject.

Methods

gobjectType :: a -> IO GType Source #

The GType for this object.

class ManagedPtrNewtype a => WrappedPtr a where Source #

Pointers to structs/unions without an associated GType.

Methods

wrappedPtrCalloc :: IO (Ptr a) Source #

Allocate a zero-initialized block of memory for the given type.

wrappedPtrCopy :: a -> IO a Source #

Make a copy of the given WrappedPtr.

wrappedPtrFree :: Maybe (FunPtr (Ptr a -> IO ())) Source #

A pointer to a function for freeing the given pointer, or Nothing is the memory associated to the pointer does not need to be freed.

data UnexpectedNullPointerReturn Source #

A common omission in the introspection data is missing (nullable) annotations for return types, when they clearly are nullable. (A common idiom is "Returns: valid value, or %NULL if something went wrong.")

Haskell wrappers will raise this exception if the return value is an unexpected nullPtr.

Constructors

UnexpectedNullPointerReturn
Fields nullPtrErrorMsg :: Text

Instances

Show UnexpectedNullPointerReturn Source #
Instance details Defined in Data.GI.Base.BasicTypes Methods showsPrec :: Int -> UnexpectedNullPointerReturn -> ShowS # show :: UnexpectedNullPointerReturn -> String # showList :: [UnexpectedNullPointerReturn] -> ShowS #
Exception UnexpectedNullPointerReturn Source #
Instance details Defined in Data.GI.Base.BasicTypes Methods toException :: UnexpectedNullPointerReturn -> SomeException # fromException :: SomeException -> Maybe UnexpectedNullPointerReturn # displayException :: UnexpectedNullPointerReturn -> String #

class NullToNothing a where Source #

Methods

nullToNothing :: MonadIO m => IO a -> m (Maybe (UnMaybe a)) Source #

Deprecated: This will be removed in future versions of haskell-gi.If you know of wrong introspection data in a binding please report it as an issue athttp:/github.comhaskell-gi/haskell-giso that it can be fixed.

Some functions are not marked as having a nullable return type in the introspection data. The result is that they currently do not return a Maybe type. This functions lets you work around this in a way that will not break when the introspection data is fixed.

When you want to call a someHaskellGIFunction that may return null wrap the call like this.

nullToNothing (someHaskellGIFunction x y)

The result will be a Maybe type even if the introspection data has not been fixed for someHaskellGIFunction yet.

Instances

a ~ UnMaybe a => NullToNothing a Source #
Instance details Defined in Data.GI.Base.BasicTypes Methods nullToNothing :: MonadIO m => IO a -> m (Maybe (UnMaybe a)) Source #
NullToNothing (Maybe a) Source #
Instance details Defined in Data.GI.Base.BasicTypes Methods nullToNothing :: MonadIO m => IO (Maybe a) -> m (Maybe (UnMaybe (Maybe a))) Source #

Basic GLib / GObject types

newtype GVariant Source #

A GVariant. See Data.GI.Base.GVariant for further methods.

Constructors

GVariant (ManagedPtr GVariant)

Instances

IsGVariant GVariant Source #
Instance details Defined in Data.GI.Base.GVariant Methods toGVariant :: GVariant -> IO GVariant Source # fromGVariant :: GVariant -> IO (Maybe GVariant) Source # toGVariantFormatString :: GVariant -> Text Source #

newtype GParamSpec Source #

A GParamSpec. See Data.GI.Base.GParamSpec for further methods.

Constructors

GParamSpec (ManagedPtr GParamSpec)

data GArray a Source #

A GArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is mapped to a list on the Haskell side.

Constructors

GArray (Ptr (GArray a))

data GPtrArray a Source #

A GPtrArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is mapped to a list on the Haskell side.

Constructors

GPtrArray (Ptr (GPtrArray a))

data GByteArray Source #

A GByteArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is packed to a ByteString on the Haskell side.

Constructors

GByteArray (Ptr GByteArray)

data GHashTable a b Source #

A GHashTable. It is mapped to a Map on the Haskell side.

Constructors

GHashTable (Ptr (GHashTable a b))

data GList a Source #

A GList, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.

Constructors

GList (Ptr (GList a))

g_list_free :: Ptr (GList a) -> IO () Source #

Free the given GList.

data GSList a Source #

A GSList, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.

Constructors

GSList (Ptr (GSList a))

g_slist_free :: Ptr (GSList a) -> IO () Source #

Free the given GSList.

class Enum a => IsGFlag a Source #

An enum usable as a flag for a function.

newtype PtrWrapped a Source #

Some APIs, such as GHashTable, pass around scalar types wrapped into a pointer. We encode such a type as follows.

Constructors

PtrWrapped
Fields unwrapPtr :: Ptr a

type GDestroyNotify a = FunPtr (Ptr a -> IO ()) Source #

Destroy the memory associated with a given pointer.