GObject.TypeClass

record (struct)

An opaque structure used as the base of all classes.

Methods

add_private

def add_private(self, private_size: int) -> None

:::warning Deprecated since 2.58 This API is deprecated. :::

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

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;
}

Parameters:

• private_size — size of private structure

get_private

def get_private(self, private_type: type | Type) -> int | None

peek_parent

def peek_parent(self) -> TypeClass

Retrieves the class structure of the immediate parent type of the class passed in.

This is a convenience function often needed in class initializers.

Since derived classes hold a reference on their parent classes as long as they are instantiated, the returned class will always exist.

This function is essentially equivalent to: TypeClass.peek (type_parent (G_TYPE_FROM_CLASS (g_class)))

unref

def unref(self) -> None

:::warning Deprecated since 2.84 This API is deprecated. :::

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 TypeClass.unref are invalid.

Static functions

adjust_private_offset

@staticmethod
def adjust_private_offset(g_class: int | None, private_size_or_offset: int) -> None

get

@staticmethod
def get(type: type | Type) -> TypeClass

Retrieves the type class of the given type.

This function will create the class on demand if it does not exist already.

If you don't want to create the class, use TypeClass.peek instead.

Parameters:

• type — type ID of a classed type

peek

@staticmethod
def peek(type: type | Type) -> TypeClass | None

Retrieves the class for a give type.

This function is essentially the same as TypeClass.get, except that the class may have not been instantiated yet.

As a consequence, this function may return None if the class of the type passed in does not currently exist (hasn't been referenced before).

Parameters:

• type — type ID of a classed type

peek_static

@staticmethod
def peek_static(type: type | Type) -> TypeClass | None

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

Parameters:

• type — type ID of a classed type

ref

@staticmethod
def ref(type: type | Type) -> TypeClass

:::warning Deprecated since 2.84 This API is deprecated. :::

Increments the reference count of the class structure belonging to type.

This function will demand-create the class if it doesn't exist already.

Parameters:

• type — type ID of a classed type

Properties

g_type

g_type: type | Type  # read/write