Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | None |
Language | Haskell2010 |
GI.GObject.Structs.TypeClass
Description
An opaque structure used as the base of all classes.
Synopsis
- newtype TypeClass = TypeClass (ManagedPtr TypeClass)
- newZeroTypeClass :: MonadIO m => m TypeClass
- typeClassAddPrivate :: (HasCallStack, MonadIO m) => TypeClass -> Word64 -> m ()
- typeClassAdjustPrivateOffset :: (HasCallStack, MonadIO m) => Ptr () -> Int32 -> m ()
- typeClassGetPrivate :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m (Ptr ())
- typeClassPeek :: (HasCallStack, MonadIO m) => GType -> m TypeClass
- typeClassPeekParent :: (HasCallStack, MonadIO m) => TypeClass -> m TypeClass
- typeClassPeekStatic :: (HasCallStack, MonadIO m) => GType -> m TypeClass
- typeClassRef :: (HasCallStack, MonadIO m) => GType -> m TypeClass
- typeClassUnref :: (HasCallStack, MonadIO m) => TypeClass -> m ()
Exported types
Memory-managed wrapper type.
Constructors
TypeClass (ManagedPtr TypeClass) |
Instances
Eq TypeClass Source # | |
CallocPtr TypeClass Source # | |
Defined in GI.GObject.Structs.TypeClass Methods boxedPtrCalloc :: IO (Ptr TypeClass) # | |
BoxedPtr TypeClass Source # | |
Defined in GI.GObject.Structs.TypeClass | |
ManagedPtrNewtype TypeClass Source # | |
Defined in GI.GObject.Structs.TypeClass Methods | |
tag ~ 'AttrSet => Constructible TypeClass tag Source # | |
Defined in GI.GObject.Structs.TypeClass |
newZeroTypeClass :: MonadIO m => m TypeClass Source #
Construct a TypeClass
struct initialized to zero.
Methods
Overloaded methods
addPrivate
Arguments
:: (HasCallStack, MonadIO m) | |
=> TypeClass |
|
-> Word64 |
|
-> m () |
Deprecated: (Since version 2.58)Use the G_ADD_PRIVATE()
macro with the G_DEFINE_*
family of macros to add instance private data to a type
Registers a private structure for an instantiatable type.
When an object is allocated, the private structures for the type and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled.
Note that the accumulated size of the private structures of a type and all its parent types cannot exceed 64 KiB.
This function should be called in the type's class_init()
function.
The private structure can be retrieved using the
G_TYPE_INSTANCE_GET_PRIVATE()
macro.
The following example shows attaching a private structure
MyObjectPrivate to an object MyObject defined in the standard
GObject fashion in the type's class_init()
function.
Note the use of a structure member "priv" to avoid the overhead
of repeatedly calling MY_OBJECT_GET_PRIVATE()
.
C code
typedef struct _MyObject MyObject; typedef struct _MyObjectPrivate MyObjectPrivate; struct _MyObject { GObject parent; MyObjectPrivate *priv; }; struct _MyObjectPrivate { int some_field; }; static void my_object_class_init (MyObjectClass *klass) { g_type_class_add_private (klass, sizeof (MyObjectPrivate)); } static void my_object_init (MyObject *my_object) { my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object, MY_TYPE_OBJECT, MyObjectPrivate); // my_object->priv->some_field will be automatically initialised to 0 } static int my_object_get_some_field (MyObject *my_object) { MyObjectPrivate *priv; g_return_val_if_fail (MY_IS_OBJECT (my_object), 0); priv = my_object->priv; return priv->some_field; }
Since: 2.4
adjustPrivateOffset
typeClassAdjustPrivateOffset :: (HasCallStack, MonadIO m) => Ptr () -> Int32 -> m () Source #
No description available in the introspection data.
getPrivate
typeClassGetPrivate :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m (Ptr ()) Source #
No description available in the introspection data.
peek
Arguments
:: (HasCallStack, MonadIO m) | |
=> GType |
|
-> m TypeClass | Returns: the |
This function is essentially the same as typeClassRef
,
except that the classes reference count isn't incremented.
As a consequence, this function may return Nothing
if the class
of the type passed in does not currently exist (hasn't been
referenced before).
peekParent
Arguments
:: (HasCallStack, MonadIO m) | |
=> TypeClass |
|
-> m TypeClass | Returns: the parent class
of |
This is a convenience function often needed in class initializers. It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist.
This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))
peekStatic
Arguments
:: (HasCallStack, MonadIO m) | |
=> GType |
|
-> m TypeClass | Returns: the |
A more efficient version of typeClassPeek
which works only for
static types.
Since: 2.4
ref
Arguments
:: (HasCallStack, MonadIO m) | |
=> GType |
|
-> m TypeClass | Returns: the |
Increments the reference count of the class structure belonging to
type
. This function will demand-create the class if it doesn't
exist already.
unref
Arguments
:: (HasCallStack, MonadIO m) | |
=> TypeClass |
|
-> m () |
Decrements the reference count of the class structure being passed in.
Once the last reference count of a class has been released, classes
may be finalized by the type system, so further dereferencing of a
class pointer after typeClassUnref
are invalid.