GI.GLib.Structs.Sequence

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

Exported types

newtype Sequence

Memory-managed wrapper type.

Constructors

Sequence (ManagedPtr Sequence)

Instances

Eq Sequence

Defined in GI.GLib.Structs.Sequence

Methods

(==) :: Sequence -> Sequence -> Bool

(/=) :: Sequence -> Sequence -> Bool

BoxedPtr Sequence

Defined in GI.GLib.Structs.Sequence

Methods

boxedPtrCopy :: Sequence -> IO Sequence

boxedPtrFree :: Sequence -> IO ()

ManagedPtrNewtype Sequence

Defined in GI.GLib.Structs.Sequence

Methods

toManagedPtr :: Sequence -> ManagedPtr Sequence

Methods

Click to display all available methods, including inherited ones

Methods

append, foreach, free, insertSorted, insertSortedIter, isEmpty, lookup, lookupIter, prepend, search, searchIter, sort, sortIter.

Getters

getBeginIter, getEndIter, getIterAtPos, getLength.

Setters

None.

append

sequenceAppend

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: the data for the new item

-> m SequenceIter

Returns: an iterator pointing to the new item

Adds a new item to the end of seq.

Since: 2.14

foreach

sequenceForeach

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Func

func: the function to call for each item in seq

-> m ()

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

Since: 2.14

foreachRange

sequenceForeachRange

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

begin: a SequenceIter

-> SequenceIter

end: a SequenceIter

-> Func

func: a Func

-> m ()

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

Since: 2.14

free

sequenceFree

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> m ()

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.

Since: 2.14

get

sequenceGet

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: a SequenceIter

-> m (Ptr ())

Returns: the data that iter points to

Returns the data that iter points to.

Since: 2.14

getBeginIter

sequenceGetBeginIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> m SequenceIter

Returns: the begin iterator for seq.

Returns the begin iterator for seq.

Since: 2.14

getEndIter

sequenceGetEndIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> m SequenceIter

Returns: the end iterator for seq

Returns the end iterator for seg

Since: 2.14

getIterAtPos

sequenceGetIterAtPos

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Int32

pos: a position in seq, or -1 for the end

-> m SequenceIter

Returns: The SequenceIter at position 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.

Since: 2.14

getLength

sequenceGetLength

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> m Int32

Returns: the length of seq

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 sequenceIsEmpty when comparing the length to zero.

Since: 2.14

insertBefore

sequenceInsertBefore

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: a SequenceIter

-> Ptr ()

data: the data for the new item

-> m SequenceIter

Returns: an iterator pointing to the new item

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

Since: 2.14

insertSorted

sequenceInsertSorted

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: the data to insert

-> CompareDataFunc

cmpFunc: the function used to compare items in the sequence

-> m SequenceIter

Returns: a SequenceIter pointing to the new item.

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

cmpFunc is called with two items of the seq, and cmpData. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.

Note that when adding a large amount of data to a Sequence, it is more efficient to do unsorted insertions and then call sequenceSort or sequenceSortIter.

Since: 2.14

insertSortedIter

sequenceInsertSortedIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: data for the new item

-> SequenceIterCompareFunc

iterCmp: the function used to compare iterators in the sequence

-> m SequenceIter

Returns: a SequenceIter pointing to the new item

Like sequenceInsertSorted, but uses a SequenceIterCompareFunc instead of a CompareDataFunc as the compare function.

iterCmp is called with two iterators pointing into seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

Note that when adding a large amount of data to a Sequence, it is more efficient to do unsorted insertions and then call sequenceSort or sequenceSortIter.

Since: 2.14

isEmpty

sequenceIsEmpty

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> m Bool

Returns: True if the sequence is empty, otherwise False.

Returns True if the sequence contains zero items.

This function is functionally identical to checking the result of sequenceGetLength being equal to zero. However this function is implemented in O(1) running time.

Since: 2.48

lookup

sequenceLookup

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: data to look up

-> CompareDataFunc

cmpFunc: the function used to compare items in the sequence

-> m (Maybe SequenceIter)

Returns: an SequenceIter pointing to the position of the first item found equal to data according to cmpFunc and cmpData, or Nothing if no such item exists

Returns an iterator pointing to the position of the first item found equal to data according to cmpFunc and cmpData. 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 sequenceIterNext and sequenceIterPrev to get others.

cmpFunc is called with two items of the seq, and cmpData. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.

This function will fail if the data contained in the sequence is unsorted.

Since: 2.28

lookupIter

sequenceLookupIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: data to look up

-> SequenceIterCompareFunc

iterCmp: the function used to compare iterators in the sequence

-> m (Maybe SequenceIter)

Returns: an SequenceIter pointing to the position of the first item found equal to data according to iterCmp and cmpData, or Nothing if no such item exists

Like sequenceLookup, but uses a SequenceIterCompareFunc instead of a CompareDataFunc as the compare function.

iterCmp is called with two iterators pointing into seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

This function will fail if the data contained in the sequence is unsorted.

Since: 2.28

move

sequenceMove

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

src: a SequenceIter pointing to the item to move

-> SequenceIter

dest: a SequenceIter pointing to the position to which the item is moved

-> m ()

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.

Since: 2.14

moveRange

sequenceMoveRange

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

dest: a SequenceIter

-> SequenceIter

begin: a SequenceIter

-> SequenceIter

end: a SequenceIter

-> m ()

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.

If dest is Nothing, the range indicated by begin and end is removed from the sequence. If dest points to a place within the (begin, end) range, the range does not move.

Since: 2.14

prepend

sequencePrepend

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: the data for the new item

-> m SequenceIter

Returns: an iterator pointing to the new item

Adds a new item to the front of seq

Since: 2.14

rangeGetMidpoint

sequenceRangeGetMidpoint

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

begin: a SequenceIter

-> SequenceIter

end: a SequenceIter

-> m SequenceIter

Returns: a SequenceIter pointing somewhere in the (begin, end) range

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.

The begin and end iterators must both point to the same sequence and begin must come before or be equal to end in the sequence.

Since: 2.14

remove

sequenceRemove

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: a SequenceIter

-> m ()

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

If the sequence has a data destroy function associated with it, this function is called on the data for the removed item.

Since: 2.14

removeRange

sequenceRemoveRange

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

begin: a SequenceIter

-> SequenceIter

end: a SequenceIter

-> m ()

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

If the sequence has a data destroy function associated with it, this function is called on the data for the removed items.

Since: 2.14

search

sequenceSearch

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: data for the new item

-> CompareDataFunc

cmpFunc: the function used to compare items in the sequence

-> m SequenceIter

Returns: an SequenceIter pointing to the position where data would have been inserted according to cmpFunc and cmpData

Returns an iterator pointing to the position where data would be inserted according to cmpFunc and cmpData.

cmpFunc is called with two items of the seq, and cmpData. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.

If you are simply searching for an existing element of the sequence, consider using sequenceLookup.

This function will fail if the data contained in the sequence is unsorted.

Since: 2.14

searchIter

sequenceSearchIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> Ptr ()

data: data for the new item

-> SequenceIterCompareFunc

iterCmp: the function used to compare iterators in the sequence

-> m SequenceIter

Returns: a SequenceIter pointing to the position in seq where data would have been inserted according to iterCmp and cmpData

Like sequenceSearch, but uses a SequenceIterCompareFunc instead of a CompareDataFunc as the compare function.

iterCmp is called with two iterators pointing into seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

If you are simply searching for an existing element of the sequence, consider using sequenceLookupIter.

This function will fail if the data contained in the sequence is unsorted.

Since: 2.14

set

sequenceSet

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: a SequenceIter

-> Ptr ()

data: new data for the item

-> m ()

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.

Since: 2.14

sort

sequenceSort

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> CompareDataFunc

cmpFunc: the function used to sort the sequence

-> m ()

Sorts seq using cmpFunc.

cmpFunc is passed two items of seq and should return 0 if they are equal, a negative value if the first comes before the second, and a positive value if the second comes before the first.

Since: 2.14

sortChanged

sequenceSortChanged

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: A SequenceIter

-> CompareDataFunc

cmpFunc: the function used to compare items in the sequence

-> m ()

Moves the data pointed to by iter to a new position as indicated by cmpFunc. This function should be called for items in a sequence already sorted according to cmpFunc whenever some aspect of an item changes so that cmpFunc may return different values for that item.

cmpFunc is called with two items of the seq, and cmpData. It should return 0 if the items are equal, a negative value if the first item comes before the second, and a positive value if the second item comes before the first.

Since: 2.14

sortChangedIter

sequenceSortChangedIter

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

iter: a SequenceIter

-> SequenceIterCompareFunc

iterCmp: the function used to compare iterators in the sequence

-> m ()

Like sequenceSortChanged, but uses a SequenceIterCompareFunc instead of a CompareDataFunc as the compare function.

iterCmp is called with two iterators pointing into the Sequence that iter points into. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

Since: 2.14

sortIter

sequenceSortIter

Arguments

:: (HasCallStack, MonadIO m)

=> Sequence

seq: a Sequence

-> SequenceIterCompareFunc

cmpFunc: the function used to compare iterators in the sequence

-> m ()

Like sequenceSort, but uses a SequenceIterCompareFunc instead of a CompareDataFunc as the compare function

cmpFunc is called with two iterators pointing into seq. It should return 0 if the iterators are equal, a negative value if the first iterator comes before the second, and a positive value if the second iterator comes before the first.

Since: 2.14

swap

sequenceSwap

Arguments

:: (HasCallStack, MonadIO m)

=> SequenceIter

a: a SequenceIter

-> SequenceIter

b: a SequenceIter

-> m ()

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

Since: 2.14