GI.GObject.Structs.TypeClass

An opaque structure used as the base of all classes.

Exported types

newtype TypeClass

Memory-managed wrapper type.

Constructors

TypeClass (ManagedPtr TypeClass)

Instances

Eq TypeClass

Defined in GI.GObject.Structs.TypeClass

Methods

(==) :: TypeClass -> TypeClass -> Bool

(/=) :: TypeClass -> TypeClass -> Bool

WrappedPtr TypeClass

Defined in GI.GObject.Structs.TypeClass

Methods

wrappedPtrCalloc :: IO (Ptr TypeClass)

wrappedPtrCopy :: TypeClass -> IO TypeClass

wrappedPtrFree :: Maybe (GDestroyNotify TypeClass)

tag ~ 'AttrSet => Constructible TypeClass tag

Defined in GI.GObject.Structs.TypeClass

Methods

new :: MonadIO m => (ManagedPtr TypeClass -> TypeClass) -> [AttrOp TypeClass tag] -> m TypeClass

newZeroTypeClass :: MonadIO m => m TypeClass

Construct a TypeClass struct initialized to zero.

noTypeClass :: Maybe TypeClass

A convenience alias for Nothing :: Maybe TypeClass.

Methods

Overloaded methods

addPrivate

typeClassAddPrivate

Arguments

:: (HasCallStack, MonadIO m)

=> TypeClass

gClass: class structure for an instantiatable type

-> Word64

privateSize: size of private structure

-> 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 ()

No description available in the introspection data.

getPrivate

typeClassGetPrivate :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m (Ptr ())

No description available in the introspection data.

peek

typeClassPeek

Arguments

:: (HasCallStack, MonadIO m)

=> GType

type: type ID of a classed type

-> m TypeClass

Returns: the TypeClass structure for the given type ID or Nothing if the class does not currently exist

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

typeClassPeekParent

Arguments

:: (HasCallStack, MonadIO m)

=> TypeClass

gClass: the TypeClass structure to retrieve the parent class for

-> m TypeClass

Returns: the parent class of gClass

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

typeClassPeekStatic

Arguments

:: (HasCallStack, MonadIO m)

=> GType

type: type ID of a classed type

-> m TypeClass

Returns: the TypeClass structure for the given type ID or Nothing if the class does not currently exist or is dynamically loaded

A more efficient version of typeClassPeek which works only for static types.

Since: 2.4

ref

typeClassRef

Arguments

:: (HasCallStack, MonadIO m)

=> GType

type: type ID of a classed type

-> m TypeClass

Returns: the TypeClass structure for the given type ID

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

typeClassUnref

Arguments

:: (HasCallStack, MonadIO m)

=> TypeClass

gClass: a TypeClass structure to unref

-> 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.