Sequence

The #GSequence struct is an opaque data type representing a sequence[glib-Sequences] data type.

class Sequence {}

Constructors

this
this(GSequence* gSequence, bool ownedRef)

Sets our main struct and passes it to the parent class.

this
this(GDestroyNotify dataDestroy)

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.

Destructor

~this
~this()
Undocumented in source.

Members

Functions

append
SequenceIter append(void* data)

Adds a new item to the end of @seq.

foreac
void foreac(GFunc func, void* userData)

Calls @func for each item in the sequence passing @user_data to the function. @func must not modify the sequence itself.

free
void free()

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.

getBeginIter
SequenceIter getBeginIter()

Returns the begin iterator for @seq.

getEndIter
SequenceIter getEndIter()

Returns the end iterator for @seg

getIterAtPos
SequenceIter getIterAtPos(int pos)

Returns the iterator at position @pos. If @pos is negative or larger than the number of items in @seq, the end iterator is returned.

getLength
int getLength()

Returns the length 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.

getSequenceStruct
GSequence* getSequenceStruct(bool transferOwnership)

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

insertSorted
SequenceIter insertSorted(void* data, GCompareDataFunc cmpFunc, void* cmpData)

Inserts @data into @sequence using @func to determine the new position. The sequence must already be sorted according to @cmp_func; otherwise the new position of @data is undefined.

insertSortedIter
SequenceIter insertSortedIter(void* data, GSequenceIterCompareFunc iterCmp, void* cmpData)

Like g_sequence_insert_sorted(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.

isEmpty
bool isEmpty()

Returns %TRUE if the sequence contains zero items.

lookup
SequenceIter lookup(void* data, GCompareDataFunc cmpFunc, void* cmpData)

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.

lookupIter
SequenceIter lookupIter(void* data, GSequenceIterCompareFunc iterCmp, void* cmpData)

Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.

prepend
SequenceIter prepend(void* data)

Adds a new item to the front of @seq

search
SequenceIter search(void* data, GCompareDataFunc cmpFunc, void* cmpData)

Returns an iterator pointing to the position where @data would be inserted according to @cmp_func and @cmp_data.

searchIter
SequenceIter searchIter(void* data, GSequenceIterCompareFunc iterCmp, void* cmpData)

Like g_sequence_search(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.

sort
void sort(GCompareDataFunc cmpFunc, void* cmpData)

Sorts @seq using @cmp_func.

sortIter
void sortIter(GSequenceIterCompareFunc cmpFunc, void* cmpData)

Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead of a GCompareDataFunc as the compare function

Static functions

foreachRange
void foreachRange(SequenceIter begin, SequenceIter end, GFunc func, void* userData)

Calls @func for each item in the range (@begin, @end) passing @user_data to the function. @func must not modify the sequence itself.

get
void* get(SequenceIter iter)

Returns the data that @iter points to.

insertBefore
SequenceIter insertBefore(SequenceIter iter, void* data)

Inserts a new item just before the item pointed to by @iter.

move
void move(SequenceIter src, SequenceIter dest)

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.

moveRange
void moveRange(SequenceIter dest, SequenceIter begin, SequenceIter end)

Inserts the (@begin, @end) range at the destination pointed to by ptr. 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.

rangeGetMidpoint
SequenceIter rangeGetMidpoint(SequenceIter begin, SequenceIter 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.

remove
void remove(SequenceIter iter)

Removes the item pointed to by @iter. It is an error to pass the end iterator to this function.

removeRange
void removeRange(SequenceIter begin, SequenceIter end)

Removes all items in the (@begin, @end) range.

set
void set(SequenceIter iter, void* data)

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.

sortChanged
void sortChanged(SequenceIter iter, GCompareDataFunc cmpFunc, void* cmpData)

Moves the data pointed 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.

sortChangedIter
void sortChangedIter(SequenceIter iter, GSequenceIterCompareFunc iterCmp, void* cmpData)

Like g_sequence_sort_changed(), but uses a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as the compare function.

swap
void swap(SequenceIter a, SequenceIter b)

Swaps the items pointed to by @a and @b. It is allowed for @a and @b to point into difference sequences.

Variables

gSequence
GSequence* gSequence;

the main Gtk struct

ownedRef
bool ownedRef;
Undocumented in source.

Meta