Sequence.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.GLib.Structs.Sequence.Sequence' struct is an opaque data type representing a
[sequence][glib-Sequences] data type.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GLib.Structs.Sequence
    ( 

-- * Exported types
    Sequence(..)                            ,
    noSequence                              ,


 -- * Methods
-- ** append #method:append#

#if ENABLE_OVERLOADING
    SequenceAppendMethodInfo                ,
#endif
    sequenceAppend                          ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    SequenceFreeMethodInfo                  ,
#endif
    sequenceFree                            ,


-- ** get #method:get#

    sequenceGet                             ,


-- ** getBeginIter #method:getBeginIter#

#if ENABLE_OVERLOADING
    SequenceGetBeginIterMethodInfo          ,
#endif
    sequenceGetBeginIter                    ,


-- ** getEndIter #method:getEndIter#

#if ENABLE_OVERLOADING
    SequenceGetEndIterMethodInfo            ,
#endif
    sequenceGetEndIter                      ,


-- ** getIterAtPos #method:getIterAtPos#

#if ENABLE_OVERLOADING
    SequenceGetIterAtPosMethodInfo          ,
#endif
    sequenceGetIterAtPos                    ,


-- ** getLength #method:getLength#

#if ENABLE_OVERLOADING
    SequenceGetLengthMethodInfo             ,
#endif
    sequenceGetLength                       ,


-- ** insertBefore #method:insertBefore#

    sequenceInsertBefore                    ,


-- ** isEmpty #method:isEmpty#

#if ENABLE_OVERLOADING
    SequenceIsEmptyMethodInfo               ,
#endif
    sequenceIsEmpty                         ,


-- ** move #method:move#

    sequenceMove                            ,


-- ** moveRange #method:moveRange#

    sequenceMoveRange                       ,


-- ** prepend #method:prepend#

#if ENABLE_OVERLOADING
    SequencePrependMethodInfo               ,
#endif
    sequencePrepend                         ,


-- ** rangeGetMidpoint #method:rangeGetMidpoint#

    sequenceRangeGetMidpoint                ,


-- ** remove #method:remove#

    sequenceRemove                          ,


-- ** removeRange #method:removeRange#

    sequenceRemoveRange                     ,


-- ** set #method:set#

    sequenceSet                             ,


-- ** swap #method:swap#

    sequenceSwap                            ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.GLib.Structs.SequenceIter as GLib.SequenceIter

-- | Memory-managed wrapper type.
newtype Sequence = Sequence (ManagedPtr Sequence)
-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance WrappedPtr Sequence where
    wrappedPtrCalloc = return nullPtr
    wrappedPtrCopy = return
    wrappedPtrFree = Nothing

-- | A convenience alias for `Nothing` :: `Maybe` `Sequence`.
noSequence :: Maybe Sequence
noSequence = Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList Sequence
type instance O.AttributeList Sequence = SequenceAttributeList
type SequenceAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method Sequence::append
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_append" g_sequence_append :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
Adds a new item to the end of /@seq@/.

/Since: 2.14/
-}
sequenceAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> Ptr ()
    {- ^ /@data@/: the data for the new item -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ an iterator pointing to the new item -}
sequenceAppend seq data_ = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_append seq' data_
    checkUnexpectedReturnNULL "sequenceAppend" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequenceAppendMethodInfo
instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceAppendMethodInfo Sequence signature where
    overloadedMethod _ = sequenceAppend

#endif

-- method Sequence::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_free" g_sequence_free :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    IO ()

{- |
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/
-}
sequenceFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> m ()
sequenceFree seq = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    g_sequence_free seq'
    touchManagedPtr seq
    return ()

#if ENABLE_OVERLOADING
data SequenceFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SequenceFreeMethodInfo Sequence signature where
    overloadedMethod _ = sequenceFree

#endif

-- method Sequence::get_begin_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_get_begin_iter" g_sequence_get_begin_iter :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
Returns the begin iterator for /@seq@/.

/Since: 2.14/
-}
sequenceGetBeginIter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ the begin iterator for /@seq@/. -}
sequenceGetBeginIter seq = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_get_begin_iter seq'
    checkUnexpectedReturnNULL "sequenceGetBeginIter" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequenceGetBeginIterMethodInfo
instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetBeginIterMethodInfo Sequence signature where
    overloadedMethod _ = sequenceGetBeginIter

#endif

-- method Sequence::get_end_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_get_end_iter" g_sequence_get_end_iter :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
Returns the end iterator for /@seg@/

/Since: 2.14/
-}
sequenceGetEndIter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ the end iterator for /@seq@/ -}
sequenceGetEndIter seq = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_get_end_iter seq'
    checkUnexpectedReturnNULL "sequenceGetEndIter" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequenceGetEndIterMethodInfo
instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetEndIterMethodInfo Sequence signature where
    overloadedMethod _ = sequenceGetEndIter

#endif

-- method Sequence::get_iter_at_pos
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a position in @seq, or -1 for the end", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_get_iter_at_pos" g_sequence_get_iter_at_pos :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    Int32 ->                                -- pos : TBasicType TInt
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
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/
-}
sequenceGetIterAtPos ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> Int32
    {- ^ /@pos@/: a position in /@seq@/, or -1 for the end -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ The 'GI.GLib.Structs.SequenceIter.SequenceIter' at position /@pos@/ -}
sequenceGetIterAtPos seq pos = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_get_iter_at_pos seq' pos
    checkUnexpectedReturnNULL "sequenceGetIterAtPos" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequenceGetIterAtPosMethodInfo
instance (signature ~ (Int32 -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequenceGetIterAtPosMethodInfo Sequence signature where
    overloadedMethod _ = sequenceGetIterAtPos

#endif

-- method Sequence::get_length
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_get_length" g_sequence_get_length :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    IO Int32

{- |
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 'GI.GLib.Structs.Sequence.sequenceIsEmpty'
when comparing the length to zero.

/Since: 2.14/
-}
sequenceGetLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> m Int32
    {- ^ __Returns:__ the length of /@seq@/ -}
sequenceGetLength seq = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_get_length seq'
    touchManagedPtr seq
    return result

#if ENABLE_OVERLOADING
data SequenceGetLengthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo SequenceGetLengthMethodInfo Sequence signature where
    overloadedMethod _ = sequenceGetLength

#endif

-- method Sequence::is_empty
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_is_empty" g_sequence_is_empty :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    IO CInt

{- |
Returns 'True' if the sequence contains zero items.

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

/Since: 2.48/
-}
sequenceIsEmpty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the sequence is empty, otherwise 'False'. -}
sequenceIsEmpty seq = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_is_empty seq'
    let result' = (/= 0) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequenceIsEmptyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo SequenceIsEmptyMethodInfo Sequence signature where
    overloadedMethod _ = sequenceIsEmpty

#endif

-- method Sequence::prepend
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "seq", argType = TInterface (Name {namespace = "GLib", name = "Sequence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequence", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_prepend" g_sequence_prepend :: 
    Ptr Sequence ->                         -- seq : TInterface (Name {namespace = "GLib", name = "Sequence"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
Adds a new item to the front of /@seq@/

/Since: 2.14/
-}
sequencePrepend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Sequence
    {- ^ /@seq@/: a 'GI.GLib.Structs.Sequence.Sequence' -}
    -> Ptr ()
    {- ^ /@data@/: the data for the new item -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ an iterator pointing to the new item -}
sequencePrepend seq data_ = liftIO $ do
    seq' <- unsafeManagedPtrGetPtr seq
    result <- g_sequence_prepend seq' data_
    checkUnexpectedReturnNULL "sequencePrepend" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr seq
    return result'

#if ENABLE_OVERLOADING
data SequencePrependMethodInfo
instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.MethodInfo SequencePrependMethodInfo Sequence signature where
    overloadedMethod _ = sequencePrepend

#endif

-- method Sequence::get
-- method type : MemberFunction
-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_get" g_sequence_get :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO (Ptr ())

{- |
Returns the data that /@iter@/ points to.

/Since: 2.14/
-}
sequenceGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m (Ptr ())
    {- ^ __Returns:__ the data that /@iter@/ points to -}
sequenceGet iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- g_sequence_get iter'
    touchManagedPtr iter
    return result

#if ENABLE_OVERLOADING
#endif

-- method Sequence::insert_before
-- method type : MemberFunction
-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_insert_before" g_sequence_insert_before :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
Inserts a new item just before the item pointed to by /@iter@/.

/Since: 2.14/
-}
sequenceInsertBefore ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> Ptr ()
    {- ^ /@data@/: the data for the new item -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ an iterator pointing to the new item -}
sequenceInsertBefore iter data_ = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- g_sequence_insert_before iter' data_
    checkUnexpectedReturnNULL "sequenceInsertBefore" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Sequence::move
-- method type : MemberFunction
-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter pointing to the item to move", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter pointing to the position to which\n    the item is moved", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_move" g_sequence_move :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- src : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- dest : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO ()

{- |
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/
-}
sequenceMove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@src@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing to the item to move -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@dest@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing to the position to which
    the item is moved -}
    -> m ()
sequenceMove src dest = liftIO $ do
    src' <- unsafeManagedPtrGetPtr src
    dest' <- unsafeManagedPtrGetPtr dest
    g_sequence_move src' dest'
    touchManagedPtr src
    touchManagedPtr dest
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Sequence::move_range
-- method type : MemberFunction
-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_move_range" g_sequence_move_range :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- dest : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO ()

{- |
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/
-}
sequenceMoveRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@dest@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m ()
sequenceMoveRange dest begin end = liftIO $ do
    dest' <- unsafeManagedPtrGetPtr dest
    begin' <- unsafeManagedPtrGetPtr begin
    end' <- unsafeManagedPtrGetPtr end
    g_sequence_move_range dest' begin' end'
    touchManagedPtr dest
    touchManagedPtr begin
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Sequence::range_get_midpoint
-- method type : MemberFunction
-- Args : [Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "SequenceIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_range_get_midpoint" g_sequence_range_get_midpoint :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO (Ptr GLib.SequenceIter.SequenceIter)

{- |
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/
-}
sequenceRangeGetMidpoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m GLib.SequenceIter.SequenceIter
    {- ^ __Returns:__ a 'GI.GLib.Structs.SequenceIter.SequenceIter' pointing somewhere in the
   (/@begin@/, /@end@/) range -}
sequenceRangeGetMidpoint begin end = liftIO $ do
    begin' <- unsafeManagedPtrGetPtr begin
    end' <- unsafeManagedPtrGetPtr end
    result <- g_sequence_range_get_midpoint begin' end'
    checkUnexpectedReturnNULL "sequenceRangeGetMidpoint" result
    result' <- (newPtr GLib.SequenceIter.SequenceIter) result
    touchManagedPtr begin
    touchManagedPtr end
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Sequence::remove
-- method type : MemberFunction
-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_remove" g_sequence_remove :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO ()

{- |
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/
-}
sequenceRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m ()
sequenceRemove iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    g_sequence_remove iter'
    touchManagedPtr iter
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Sequence::remove_range
-- method type : MemberFunction
-- Args : [Arg {argCName = "begin", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_remove_range" g_sequence_remove_range :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- begin : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- end : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO ()

{- |
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/
-}
sequenceRemoveRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@begin@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@end@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m ()
sequenceRemoveRange begin end = liftIO $ do
    begin' <- unsafeManagedPtrGetPtr begin
    end' <- unsafeManagedPtrGetPtr end
    g_sequence_remove_range begin' end'
    touchManagedPtr begin
    touchManagedPtr end
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Sequence::set
-- method type : MemberFunction
-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new data for the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_set" g_sequence_set :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- iter : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

{- |
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/
-}
sequenceSet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@iter@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> Ptr ()
    {- ^ /@data@/: new data for the item -}
    -> m ()
sequenceSet iter data_ = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    g_sequence_set iter' data_
    touchManagedPtr iter
    return ()

#if ENABLE_OVERLOADING
#endif

-- method Sequence::swap
-- method type : MemberFunction
-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "GLib", name = "SequenceIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSequenceIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_sequence_swap" g_sequence_swap :: 
    Ptr GLib.SequenceIter.SequenceIter ->   -- a : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    Ptr GLib.SequenceIter.SequenceIter ->   -- b : TInterface (Name {namespace = "GLib", name = "SequenceIter"})
    IO ()

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

/Since: 2.14/
-}
sequenceSwap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.SequenceIter.SequenceIter
    {- ^ /@a@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> GLib.SequenceIter.SequenceIter
    {- ^ /@b@/: a 'GI.GLib.Structs.SequenceIter.SequenceIter' -}
    -> m ()
sequenceSwap a b = liftIO $ do
    a' <- unsafeManagedPtrGetPtr a
    b' <- unsafeManagedPtrGetPtr b
    g_sequence_swap a' b'
    touchManagedPtr a
    touchManagedPtr b
    return ()

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type family ResolveSequenceMethod (t :: Symbol) (o :: *) :: * where
    ResolveSequenceMethod "append" o = SequenceAppendMethodInfo
    ResolveSequenceMethod "free" o = SequenceFreeMethodInfo
    ResolveSequenceMethod "isEmpty" o = SequenceIsEmptyMethodInfo
    ResolveSequenceMethod "prepend" o = SequencePrependMethodInfo
    ResolveSequenceMethod "getBeginIter" o = SequenceGetBeginIterMethodInfo
    ResolveSequenceMethod "getEndIter" o = SequenceGetEndIterMethodInfo
    ResolveSequenceMethod "getIterAtPos" o = SequenceGetIterAtPosMethodInfo
    ResolveSequenceMethod "getLength" o = SequenceGetLengthMethodInfo
    ResolveSequenceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSequenceMethod t Sequence, O.MethodInfo info Sequence p) => OL.IsLabel t (Sequence -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif