A destructor is present on this object, but not explicitly documented in the source.
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.
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 glib.sequence.Sequence.isEmpty when comparing the length to zero.
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 glib.sequence.Sequence.insertSorted, 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 glib.sequence_iter.SequenceIter.next and glib.sequence_iter.SequenceIter.prev to get others.
Like glib.sequence.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 glib.sequence.Sequence.search, but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.
Sorts seq using cmp_func.
Like glib.sequence.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 glib.sequence.Sequence.sortChanged, 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.