MiniObject

#GstMiniObject is a simple structure that can be used to implement refcounted types.

Subclasses will include #GstMiniObject as the first member in their structure and then call gst_mini_object_init() to initialize the #GstMiniObject fields.

gst_mini_object_ref() and gst_mini_object_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 %TRUE, the free function of the miniobject is called.

A copy can be made with gst_mini_object_copy().

gst_mini_object_is_writable() will return %TRUE when the refcount of the object is exactly 1, meaning the current caller has the only reference to the object. gst_mini_object_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 #GstMiniObject with gst_mini_object_set_qdata() and gst_mini_object_get_qdata(). The data is meant to be specific to the particular object and is not automatically copied with gst_mini_object_copy() or similar methods.

A weak reference can be added and remove with gst_mini_object_weak_ref() and gst_mini_object_weak_unref() respectively.

class MiniObject {

protected

GstMiniObject* gstMiniObject;

protected

bool ownedRef;

GstMiniObject* getMiniObjectStruct();

void* getStruct();

this(GstMiniObject* gstMiniObject, bool ownedRef);

MiniObject copy();

void* getQdata(GQuark quark);

void init(uint flags, GType type, GstMiniObjectCopyFunction copyFunc, GstMiniObjectDisposeFunction disposeFunc, GstMiniObjectFreeFunction freeFunc);

bool isWritable();

bool lock(GstLockFlags flags);

MiniObject makeWritable();

MiniObject doref();

void setQdata(GQuark quark, void* data, GDestroyNotify destroy);

void* stealQdata(GQuark quark);

void unlock(GstLockFlags flags);

void unref();

void weakRef(GstMiniObjectNotify notify, void* data);

void weakUnref(GstMiniObjectNotify notify, void* data);

static bool replace(MiniObject olddata, MiniObject newdata);

static MiniObject steal(MiniObject olddata);

static bool take(MiniObject olddata, MiniObject newdata);

}

Constructors

this this(GstMiniObject* gstMiniObject, bool ownedRef): Sets our main struct and passes it to the parent class.

Members

Functions

copy MiniObject copy(): Creates a copy of the mini-object.
doref MiniObject doref(): Increase the reference count of the mini-object.
getMiniObjectStruct GstMiniObject* getMiniObjectStruct(): Get the main Gtk struct
getQdata void* getQdata(GQuark quark): This function gets back user data pointers stored via gst_mini_object_set_qdata().
getStruct void* getStruct(): the main Gtk struct as a void*
init void init(uint flags, GType type, GstMiniObjectCopyFunction copyFunc, GstMiniObjectDisposeFunction disposeFunc, GstMiniObjectFreeFunction freeFunc): Initializes a mini-object with the desired type and copy/dispose/free functions.
isWritable bool isWritable(): 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.
lock bool lock(GstLockFlags flags): Lock the mini-object with the specified access mode in @flags.
makeWritable MiniObject makeWritable(): Checks if a mini-object is writable. If not, a writable copy is made and returned. This gives away the reference to the original mini object, and returns a reference to the new object.
setQdata void setQdata(GQuark quark, void* data, GDestroyNotify destroy): This sets an opaque, named pointer on a miniobject. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @object with gst_mini_object_get_qdata() until the @object is disposed. Setting a previously set user data pointer, overrides (frees) the old pointer set, using %NULL as pointer essentially removes the data stored.
stealQdata void* stealQdata(GQuark quark): This function gets back user data pointers stored via gst_mini_object_set_qdata() and removes the data from @object without invoking its destroy() function (if any was set).
unlock void unlock(GstLockFlags flags): Unlock the mini-object with the specified access mode in @flags.
unref void unref(): Decreases the reference count of the mini-object, possibly freeing the mini-object.
weakRef void weakRef(GstMiniObjectNotify notify, void* data): Adds a weak reference callback to a mini object. Weak references are used for notification when a mini object is finalized. They are called "weak references" because they allow you to safely hold a pointer to the mini object without calling gst_mini_object_ref() (gst_mini_object_ref() adds a strong reference, that is, forces the object to stay alive).
weakUnref void weakUnref(GstMiniObjectNotify notify, void* data): Removes a weak reference callback from a mini object.

Static functions

replace bool replace(MiniObject olddata, MiniObject newdata): 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.
steal MiniObject steal(MiniObject olddata): Replace the current #GstMiniObject pointer to by @olddata with %NULL and return the old value.
take bool take(MiniObject olddata, MiniObject newdata): Modifies a pointer to point to a new mini-object. The modification is done atomically. This version is similar to gst_mini_object_replace() except that it does not increase the refcount of @newdata and thus takes ownership of @newdata.

Variables

gstMiniObject GstMiniObject* gstMiniObject;: the main Gtk struct
ownedRef bool ownedRef;: Undocumented in source.