{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Sequence
(
Sequence(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveSequenceMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SequenceAppendMethodInfo ,
#endif
sequenceAppend ,
#if defined(ENABLE_OVERLOADING)
SequenceFreeMethodInfo ,
#endif
sequenceFree ,
sequenceGet ,
#if defined(ENABLE_OVERLOADING)
SequenceGetBeginIterMethodInfo ,
#endif
sequenceGetBeginIter ,
#if defined(ENABLE_OVERLOADING)
SequenceGetEndIterMethodInfo ,
#endif
sequenceGetEndIter ,
#if defined(ENABLE_OVERLOADING)
SequenceGetIterAtPosMethodInfo ,
#endif
sequenceGetIterAtPos ,
#if defined(ENABLE_OVERLOADING)
SequenceGetLengthMethodInfo ,
#endif
sequenceGetLength ,
sequenceInsertBefore ,
#if defined(ENABLE_OVERLOADING)
SequenceIsEmptyMethodInfo ,
#endif
sequenceIsEmpty ,
sequenceMove ,
sequenceMoveRange ,
#if defined(ENABLE_OVERLOADING)
SequencePrependMethodInfo ,
#endif
sequencePrepend ,
sequenceRangeGetMidpoint ,
sequenceRemove ,
sequenceRemoveRange ,
sequenceSet ,
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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.GLib.Structs.SequenceIter as GLib.SequenceIter
newtype Sequence = Sequence (SP.ManagedPtr Sequence)
deriving (Sequence -> Sequence -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sequence -> Sequence -> Bool
$c/= :: Sequence -> Sequence -> Bool
== :: Sequence -> Sequence -> Bool
$c== :: Sequence -> Sequence -> Bool
Eq)
instance SP.ManagedPtrNewtype Sequence where
toManagedPtr :: Sequence -> ManagedPtr Sequence
toManagedPtr (Sequence ManagedPtr Sequence
p) = ManagedPtr Sequence
p
instance BoxedPtr Sequence where
boxedPtrCopy :: Sequence -> IO Sequence
boxedPtrCopy = forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: Sequence -> IO ()
boxedPtrFree = \Sequence
_x -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Sequence
type instance O.AttributeList Sequence = SequenceAttributeList
type SequenceAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_sequence_append" g_sequence_append ::
Ptr Sequence ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> m GLib.SequenceIter.SequenceIter
sequenceAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> m SequenceIter
sequenceAppend Sequence
seq Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr SequenceIter
result <- Ptr Sequence -> Ptr () -> IO (Ptr SequenceIter)
g_sequence_append Ptr Sequence
seq' Ptr ()
data_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceAppend" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceAppendMethodInfo
instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceAppendMethodInfo Sequence signature where
overloadedMethod = sequenceAppend
instance O.OverloadedMethodInfo SequenceAppendMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceAppend"
})
#endif
foreign import ccall "g_sequence_free" g_sequence_free ::
Ptr Sequence ->
IO ()
sequenceFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> m ()
sequenceFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Sequence -> m ()
sequenceFree Sequence
seq = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr Sequence -> IO ()
g_sequence_free Ptr Sequence
seq'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SequenceFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SequenceFreeMethodInfo Sequence signature where
overloadedMethod = sequenceFree
instance O.OverloadedMethodInfo SequenceFreeMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceFree"
})
#endif
foreign import ccall "g_sequence_get_begin_iter" g_sequence_get_begin_iter ::
Ptr Sequence ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceGetBeginIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> m GLib.SequenceIter.SequenceIter
sequenceGetBeginIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> m SequenceIter
sequenceGetBeginIter Sequence
seq = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr SequenceIter
result <- Ptr Sequence -> IO (Ptr SequenceIter)
g_sequence_get_begin_iter Ptr Sequence
seq'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetBeginIter" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceGetBeginIterMethodInfo
instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceGetBeginIterMethodInfo Sequence signature where
overloadedMethod = sequenceGetBeginIter
instance O.OverloadedMethodInfo SequenceGetBeginIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceGetBeginIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceGetBeginIter"
})
#endif
foreign import ccall "g_sequence_get_end_iter" g_sequence_get_end_iter ::
Ptr Sequence ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceGetEndIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> m GLib.SequenceIter.SequenceIter
sequenceGetEndIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> m SequenceIter
sequenceGetEndIter Sequence
seq = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr SequenceIter
result <- Ptr Sequence -> IO (Ptr SequenceIter)
g_sequence_get_end_iter Ptr Sequence
seq'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetEndIter" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceGetEndIterMethodInfo
instance (signature ~ (m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceGetEndIterMethodInfo Sequence signature where
overloadedMethod = sequenceGetEndIter
instance O.OverloadedMethodInfo SequenceGetEndIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceGetEndIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceGetEndIter"
})
#endif
foreign import ccall "g_sequence_get_iter_at_pos" g_sequence_get_iter_at_pos ::
Ptr Sequence ->
Int32 ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceGetIterAtPos ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Int32
-> m GLib.SequenceIter.SequenceIter
sequenceGetIterAtPos :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Int32 -> m SequenceIter
sequenceGetIterAtPos Sequence
seq Int32
pos = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr SequenceIter
result <- Ptr Sequence -> Int32 -> IO (Ptr SequenceIter)
g_sequence_get_iter_at_pos Ptr Sequence
seq' Int32
pos
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetIterAtPos" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceGetIterAtPosMethodInfo
instance (signature ~ (Int32 -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceGetIterAtPosMethodInfo Sequence signature where
overloadedMethod = sequenceGetIterAtPos
instance O.OverloadedMethodInfo SequenceGetIterAtPosMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceGetIterAtPos",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceGetIterAtPos"
})
#endif
foreign import ccall "g_sequence_get_length" g_sequence_get_length ::
Ptr Sequence ->
IO Int32
sequenceGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> m Int32
sequenceGetLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> m Int32
sequenceGetLength Sequence
seq = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Int32
result <- Ptr Sequence -> IO Int32
g_sequence_get_length Ptr Sequence
seq'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data SequenceGetLengthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod SequenceGetLengthMethodInfo Sequence signature where
overloadedMethod = sequenceGetLength
instance O.OverloadedMethodInfo SequenceGetLengthMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceGetLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceGetLength"
})
#endif
foreign import ccall "g_sequence_is_empty" g_sequence_is_empty ::
Ptr Sequence ->
IO CInt
sequenceIsEmpty ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> m Bool
sequenceIsEmpty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> m Bool
sequenceIsEmpty Sequence
seq = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
CInt
result <- Ptr Sequence -> IO CInt
g_sequence_is_empty Ptr Sequence
seq'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SequenceIsEmptyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SequenceIsEmptyMethodInfo Sequence signature where
overloadedMethod = sequenceIsEmpty
instance O.OverloadedMethodInfo SequenceIsEmptyMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceIsEmpty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequenceIsEmpty"
})
#endif
foreign import ccall "g_sequence_prepend" g_sequence_prepend ::
Ptr Sequence ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequencePrepend ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> m GLib.SequenceIter.SequenceIter
sequencePrepend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> m SequenceIter
sequencePrepend Sequence
seq Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr SequenceIter
result <- Ptr Sequence -> Ptr () -> IO (Ptr SequenceIter)
g_sequence_prepend Ptr Sequence
seq' Ptr ()
data_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequencePrepend" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequencePrependMethodInfo
instance (signature ~ (Ptr () -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequencePrependMethodInfo Sequence signature where
overloadedMethod = sequencePrepend
instance O.OverloadedMethodInfo SequencePrependMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequencePrepend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Sequence.html#v:sequencePrepend"
})
#endif
foreign import ccall "g_sequence_get" g_sequence_get ::
Ptr GLib.SequenceIter.SequenceIter ->
IO (Ptr ())
sequenceGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> m (Ptr ())
sequenceGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> m (Ptr ())
sequenceGet SequenceIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr ()
result <- Ptr SequenceIter -> IO (Ptr ())
g_sequence_get Ptr SequenceIter
iter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_insert_before" g_sequence_insert_before ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceInsertBefore ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> Ptr ()
-> m GLib.SequenceIter.SequenceIter
sequenceInsertBefore :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> Ptr () -> m SequenceIter
sequenceInsertBefore SequenceIter
iter Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr SequenceIter
result <- Ptr SequenceIter -> Ptr () -> IO (Ptr SequenceIter)
g_sequence_insert_before Ptr SequenceIter
iter' Ptr ()
data_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceInsertBefore" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_move" g_sequence_move ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
IO ()
sequenceMove ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> m ()
sequenceMove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> m ()
sequenceMove SequenceIter
src SequenceIter
dest = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
src' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
src
Ptr SequenceIter
dest' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
dest
Ptr SequenceIter -> Ptr SequenceIter -> IO ()
g_sequence_move Ptr SequenceIter
src' Ptr SequenceIter
dest'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
src
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
dest
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_move_range" g_sequence_move_range ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
IO ()
sequenceMoveRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> m ()
sequenceMoveRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> SequenceIter -> m ()
sequenceMoveRange SequenceIter
dest SequenceIter
begin SequenceIter
end = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
dest' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
dest
Ptr SequenceIter
begin' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
end
Ptr SequenceIter -> Ptr SequenceIter -> Ptr SequenceIter -> IO ()
g_sequence_move_range Ptr SequenceIter
dest' Ptr SequenceIter
begin' Ptr SequenceIter
end'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
dest
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_range_get_midpoint" g_sequence_range_get_midpoint ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceRangeGetMidpoint ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> m GLib.SequenceIter.SequenceIter
sequenceRangeGetMidpoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> m SequenceIter
sequenceRangeGetMidpoint SequenceIter
begin SequenceIter
end = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
begin' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
end
Ptr SequenceIter
result <- Ptr SequenceIter -> Ptr SequenceIter -> IO (Ptr SequenceIter)
g_sequence_range_get_midpoint Ptr SequenceIter
begin' Ptr SequenceIter
end'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceRangeGetMidpoint" Ptr SequenceIter
result
SequenceIter
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_remove" g_sequence_remove ::
Ptr GLib.SequenceIter.SequenceIter ->
IO ()
sequenceRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> m ()
sequenceRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> m ()
sequenceRemove SequenceIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr SequenceIter -> IO ()
g_sequence_remove Ptr SequenceIter
iter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_remove_range" g_sequence_remove_range ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
IO ()
sequenceRemoveRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> m ()
sequenceRemoveRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> m ()
sequenceRemoveRange SequenceIter
begin SequenceIter
end = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
begin' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
end
Ptr SequenceIter -> Ptr SequenceIter -> IO ()
g_sequence_remove_range Ptr SequenceIter
begin' Ptr SequenceIter
end'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_set" g_sequence_set ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr () ->
IO ()
sequenceSet ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> Ptr ()
-> m ()
sequenceSet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> Ptr () -> m ()
sequenceSet SequenceIter
iter Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr SequenceIter -> Ptr () -> IO ()
g_sequence_set Ptr SequenceIter
iter' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_swap" g_sequence_swap ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
IO ()
sequenceSwap ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> m ()
sequenceSwap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> m ()
sequenceSwap SequenceIter
a SequenceIter
b = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
a' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
a
Ptr SequenceIter
b' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
b
Ptr SequenceIter -> Ptr SequenceIter -> IO ()
g_sequence_swap Ptr SequenceIter
a' Ptr SequenceIter
b'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
a
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
b
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSequenceMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod info Sequence p) => OL.IsLabel t (Sequence -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveSequenceMethod t Sequence, O.OverloadedMethod info Sequence p, R.HasField t Sequence p) => R.HasField t Sequence p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSequenceMethod t Sequence, O.OverloadedMethodInfo info Sequence) => OL.IsLabel t (O.MethodProxy info Sequence) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif