gi-glib-2.0.30: GLib bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | Safe-Inferred
Language | Haskell2010

GI.GLib.Structs.Sequence

Contents

- Exported types
- Methods
  - append
  - foreach
  - foreachRange
  - free
  - get
  - getBeginIter
  - getEndIter
  - getIterAtPos
  - getLength
  - insertBefore
  - insertSorted
  - insertSortedIter
  - isEmpty
  - lookup
  - lookupIter
  - move
  - moveRange
  - prepend
  - rangeGetMidpoint
  - remove
  - removeRange
  - search
  - searchIter
  - set
  - sort
  - sortChanged
  - sortChangedIter
  - sortIter
  - swap

Description

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

Synopsis

- newtype Sequence = Sequence (ManagedPtr Sequence)
- sequenceAppend :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> m SequenceIter
- sequenceForeach :: (HasCallStack, MonadIO m) => Sequence -> Func -> m ()
- sequenceForeachRange :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> Func -> m ()
- sequenceFree :: (HasCallStack, MonadIO m) => Sequence -> m ()
- sequenceGet :: (HasCallStack, MonadIO m) => SequenceIter -> m (Ptr ())
- sequenceGetBeginIter :: (HasCallStack, MonadIO m) => Sequence -> m SequenceIter
- sequenceGetEndIter :: (HasCallStack, MonadIO m) => Sequence -> m SequenceIter
- sequenceGetIterAtPos :: (HasCallStack, MonadIO m) => Sequence -> Int32 -> m SequenceIter
- sequenceGetLength :: (HasCallStack, MonadIO m) => Sequence -> m Int32
- sequenceInsertBefore :: (HasCallStack, MonadIO m) => SequenceIter -> Ptr () -> m SequenceIter
- sequenceInsertSorted :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> CompareDataFunc -> m SequenceIter
- sequenceInsertSortedIter :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> SequenceIterCompareFunc -> m SequenceIter
- sequenceIsEmpty :: (HasCallStack, MonadIO m) => Sequence -> m Bool
- sequenceLookup :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> CompareDataFunc -> m (Maybe SequenceIter)
- sequenceLookupIter :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> SequenceIterCompareFunc -> m (Maybe SequenceIter)
- sequenceMove :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> m ()
- sequenceMoveRange :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> SequenceIter -> m ()
- sequencePrepend :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> m SequenceIter
- sequenceRangeGetMidpoint :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> m SequenceIter
- sequenceRemove :: (HasCallStack, MonadIO m) => SequenceIter -> m ()
- sequenceRemoveRange :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> m ()
- sequenceSearch :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> CompareDataFunc -> m SequenceIter
- sequenceSearchIter :: (HasCallStack, MonadIO m) => Sequence -> Ptr () -> SequenceIterCompareFunc -> m SequenceIter
- sequenceSet :: (HasCallStack, MonadIO m) => SequenceIter -> Ptr () -> m ()
- sequenceSort :: (HasCallStack, MonadIO m) => Sequence -> CompareDataFunc -> m ()
- sequenceSortChanged :: (HasCallStack, MonadIO m) => SequenceIter -> CompareDataFunc -> m ()
- sequenceSortChangedIter :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIterCompareFunc -> m ()
- sequenceSortIter :: (HasCallStack, MonadIO m) => Sequence -> SequenceIterCompareFunc -> m ()
- sequenceSwap :: (HasCallStack, MonadIO m) => SequenceIter -> SequenceIter -> m ()

# Exported types

newtype Sequence Source #

Memory-managed wrapper type.

Constructors

Sequence (ManagedPtr Sequence) |

#### Instances

Instances details

Eq Sequence Source # |
Instance details Defined in GI.GLib.Structs.Sequence Methods (==) :: Sequence -> Sequence -> Bool Source # (/=) :: Sequence -> Sequence -> Bool Source #
BoxedPtr Sequence Source # |
Instance details Defined in GI.GLib.Structs.Sequence Methods boxedPtrCopy :: Sequence -> IO Sequence Source # boxedPtrFree :: Sequence -> IO () Source #
ManagedPtrNewtype Sequence Source # |
Instance details Defined in GI.GLib.Structs.Sequence Methods toManagedPtr :: Sequence -> ManagedPtr Sequence Source #

# Methods

### Click to display all available methods, including inherited ones

Expand

#### Methods

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

#### Getters

getBeginIter, getEndIter, getIterAtPos, getLength.

#### Setters

None.

## append

sequenceAppend Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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