Sets our main struct and passes it to the parent class.
Creates a new GSequence. The @data_destroy function, if non-%NULL will be called on all items when the sequence is destroyed and on items that are removed from the sequence.
Adds a new item to the end of @seq.
Calls @func for each item in the sequence passing @user_data to the function. @func must not modify the sequence itself.
Frees the memory allocated for @seq. If @seq has a data destroy function associated with it, that function is called on all items in @seq.
Returns the begin iterator for @seq.
Returns the end iterator for @seg
Returns the iterator at position @pos. If @pos is negative or larger than the number of items in @seq, the end iterator is returned.
Returns the positive length (>= 0) of @seq. Note that this method is O(h) where `h' is the height of the tree. It is thus more efficient to use g_sequence_is_empty() when comparing the length to zero.
Get the main Gtk struct
the main Gtk struct as a void*
Inserts @data into @seq using @cmp_func to determine the new position. The sequence must already be sorted according to @cmp_func; otherwise the new position of @data is undefined.
Like g_sequence_insert_sorted(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.
Returns %TRUE if the sequence contains zero items.
Returns an iterator pointing to the position of the first item found equal to @data according to @cmp_func and @cmp_data. If more than one item is equal, it is not guaranteed that it is the first which is returned. In that case, you can use g_sequence_iter_next() and g_sequence_iter_prev() to get others.
Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.
Adds a new item to the front of @seq
Returns an iterator pointing to the position where @data would be inserted according to @cmp_func and @cmp_data.
Like g_sequence_search(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.
Sorts @seq using @cmp_func.
Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function
Calls @func for each item in the range (@begin, @end) passing @user_data to the function. @func must not modify the sequence itself.
Returns the data that @iter points to.
Inserts a new item just before the item pointed to by @iter.
Moves the item pointed to by @src to the position indicated by @dest. After calling this function @dest will point to the position immediately after @src. It is allowed for @src and @dest to point into different sequences.
Inserts the (@begin, @end) range at the destination pointed to by @dest. The @begin and @end iters must point into the same sequence. It is allowed for @dest to point to a different sequence than the one pointed into by @begin and @end.
Finds an iterator somewhere in the range (@begin, @end). This iterator will be close to the middle of the range, but is not guaranteed to be exactly in the middle.
Removes the item pointed to by @iter. It is an error to pass the end iterator to this function.
Removes all items in the (@begin, @end) range.
Changes the data for the item pointed to by @iter to be @data. If the sequence has a data destroy function associated with it, that function is called on the existing data that @iter pointed to.
Moves the data pointed to by @iter to a new position as indicated by @cmp_func. This function should be called for items in a sequence already sorted according to @cmp_func whenever some aspect of an item changes so that @cmp_func may return different values for that item.
Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.
Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences.
The #GSequence struct is an opaque data type representing a sequence[glib-Sequences] data type.