:right-sidebar: True

MiniObject
===================================================================

.. currentmodule:: gi.repository.Gst





.. class:: MiniObject(*args, **kwargs)
   :no-contents-entry:






:obj:`~gi.repository.Gst.MiniObject` is a simple structure that can be used to implement refcounted
types.

Subclasses will include :obj:`~gi.repository.Gst.MiniObject` as the first member in their structure
and then call :func:`~gi.repository.Gst.MiniObject.init` to initialize the :obj:`~gi.repository.Gst.MiniObject` fields.

:func:`~gi.repository.Gst.MiniObject.ref` and :func:`~gi.repository.Gst.MiniObject.unref` increment and decrement the
refcount respectively. When the refcount of a mini-object reaches 0, the
dispose function is called first and when this returns :const:`True`, the free
function of the miniobject is called.

A copy can be made with :func:`~gi.repository.Gst.MiniObject.copy`.

:func:`~gi.repository.Gst.MiniObject.is_writable` will return :const:`True` when the refcount of the
object is exactly 1 and there is no parent or a single parent exists and is
writable itself, meaning the current caller has the only reference to the
object. :func:`~gi.repository.Gst.MiniObject.make_writable` will return a writable version of
the object, which might be a new copy when the refcount was not 1.

Opaque data can be associated with a :obj:`~gi.repository.Gst.MiniObject` with
:func:`~gi.repository.Gst.MiniObject.set_qdata` and :func:`~gi.repository.Gst.MiniObject.get_qdata`. The data is
meant to be specific to the particular object and is not automatically copied
with :func:`~gi.repository.Gst.MiniObject.copy` or similar methods.

A weak reference can be added and remove with :func:`~gi.repository.Gst.MiniObject.weak_ref`
and :func:`~gi.repository.Gst.MiniObject.weak_unref` respectively.




Methods
-------

.. rst-class:: interim-class

.. class:: MiniObject
   :no-index:


   .. method:: add_parent(parent: ~gi.repository.Gst.MiniObject) -> None

      This adds ``parent`` as a parent for ``object``\. Having one ore more parents affects the
      writability of ``object``\: if a ``parent`` is not writable, ``object`` is also not
      writable, regardless of its refcount. ``object`` is only writable if all
      the parents are writable and its own refcount is exactly 1.

      Note: This function does not take ownership of ``parent`` and also does not
      take an additional reference. It is the responsibility of the caller to
      remove the parent again at a later time.


      .. versionadded:: 1.16





      :param parent: a parent :obj:`~gi.repository.Gst.MiniObject`




   .. method:: get_qdata(quark: int) -> ~typing.Any | None

      This function gets back user data pointers stored via
      :func:`~gi.repository.Gst.MiniObject.set_qdata`.






      :param quark: A :obj:`~gi.repository.GLib.Quark`\, naming the user data pointer




   .. method:: is_writable() -> bool

      If ``mini_object`` has the LOCKABLE flag set, check if the current EXCLUSIVE
      lock on ``object`` is the only one, this means that changes to the object will
      not be visible to any other object.

      If the LOCKABLE flag is not set, check if the refcount of ``mini_object`` is
      exactly 1, meaning that no other reference exists to the object and that the
      object is therefore writable.

      Modification of a mini-object should only be done after verifying that it
      is writable.









   .. method:: lock(flags: ~gi.repository.Gst.LockFlags) -> bool

      Lock the mini-object with the specified access mode in ``flags``\.






      :param flags: :obj:`~gi.repository.Gst.LockFlags`




   .. method:: remove_parent(parent: ~gi.repository.Gst.MiniObject) -> None

      This removes ``parent`` as a parent for ``object``\. See
      :func:`~gi.repository.Gst.MiniObject.add_parent`.


      .. versionadded:: 1.16





      :param parent: a parent :obj:`~gi.repository.Gst.MiniObject`




   .. classmethod:: replace(newdata: ~gi.repository.Gst.MiniObject | None = None) -> ~typing.Tuple[bool, ~gi.repository.Gst.MiniObject | None]

      Atomically modifies a pointer to point to a new mini-object.
      The reference count of ``olddata`` is decreased and the reference count of
      ``newdata`` is increased.

      Either ``newdata`` and the value pointed to by ``olddata`` may be :const:`None`.






      :param newdata: pointer to new mini-object




   .. method:: set_qdata(quark: int, data: ~typing.Any, destroy: ~typing.Callable[[~typing.Any], None]) -> None

      This sets an opaque, named pointer on a miniobject.
      The name is specified through a :obj:`~gi.repository.GLib.Quark` (retrieved e.g. via
      :func:`~gi.repository.GLib.quark_from_static_string`), and the pointer
      can be gotten back from the ``object`` with :func:`~gi.repository.Gst.MiniObject.get_qdata`
      until the ``object`` is disposed.
      Setting a previously set user data pointer, overrides (frees)
      the old pointer set, using :const:`None` as pointer essentially
      removes the data stored.

      ``destroy`` may be specified which is called with ``data`` as argument
      when the ``object`` is disposed, or the data is being overwritten by
      a call to :func:`~gi.repository.Gst.MiniObject.set_qdata` with the same ``quark``\.






      :param quark: A :obj:`~gi.repository.GLib.Quark`\, naming the user data pointer

      :param data: An opaque user data pointer

      :param destroy: Function to invoke with ``data`` as argument, when ``data``
                   needs to be freed




   .. classmethod:: take(newdata: ~gi.repository.Gst.MiniObject) -> ~typing.Tuple[bool, ~gi.repository.Gst.MiniObject]

      Modifies a pointer to point to a new mini-object. The modification
      is done atomically. This version is similar to :func:`~gi.repository.Gst.MiniObject.replace`
      except that it does not increase the refcount of ``newdata`` and thus
      takes ownership of ``newdata``\.

      Either ``newdata`` and the value pointed to by ``olddata`` may be :const:`None`.






      :param newdata: pointer to new mini-object




   .. method:: unlock(flags: ~gi.repository.Gst.LockFlags) -> None

      Unlock the mini-object with the specified access mode in ``flags``\.






      :param flags: :obj:`~gi.repository.Gst.LockFlags`














Fields
------

.. rst-class:: interim-class

.. class:: MiniObject
   :no-index:
   

   .. attribute:: copy

      A copy function






   .. attribute:: dispose

      A dispose function






   .. attribute:: flags

      Extra flags.






   .. attribute:: free

      The free function






   .. attribute:: lockstate

      Atomic state of the locks






   .. attribute:: priv_pointer

      






   .. attribute:: priv_uint

      






   .. attribute:: refcount

      Atomic refcount






   .. attribute:: type

      The GType of the object