{-# 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)
SequenceForeachMethodInfo ,
#endif
sequenceForeach ,
sequenceForeachRange ,
#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)
SequenceInsertSortedMethodInfo ,
#endif
sequenceInsertSorted ,
#if defined(ENABLE_OVERLOADING)
SequenceInsertSortedIterMethodInfo ,
#endif
sequenceInsertSortedIter ,
#if defined(ENABLE_OVERLOADING)
SequenceIsEmptyMethodInfo ,
#endif
sequenceIsEmpty ,
#if defined(ENABLE_OVERLOADING)
SequenceLookupMethodInfo ,
#endif
sequenceLookup ,
#if defined(ENABLE_OVERLOADING)
SequenceLookupIterMethodInfo ,
#endif
sequenceLookupIter ,
sequenceMove ,
sequenceMoveRange ,
#if defined(ENABLE_OVERLOADING)
SequencePrependMethodInfo ,
#endif
sequencePrepend ,
sequenceRangeGetMidpoint ,
sequenceRemove ,
sequenceRemoveRange ,
#if defined(ENABLE_OVERLOADING)
SequenceSearchMethodInfo ,
#endif
sequenceSearch ,
#if defined(ENABLE_OVERLOADING)
SequenceSearchIterMethodInfo ,
#endif
sequenceSearchIter ,
sequenceSet ,
#if defined(ENABLE_OVERLOADING)
SequenceSortMethodInfo ,
#endif
sequenceSort ,
sequenceSortChanged ,
sequenceSortChangedIter ,
#if defined(ENABLE_OVERLOADING)
SequenceSortIterMethodInfo ,
#endif
sequenceSortIter ,
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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.SequenceIter as GLib.SequenceIter
#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.SequenceIter as GLib.SequenceIter
#endif
newtype Sequence = Sequence (SP.ManagedPtr Sequence)
deriving (Sequence -> Sequence -> Bool
(Sequence -> Sequence -> Bool)
-> (Sequence -> Sequence -> Bool) -> Eq Sequence
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sequence -> Sequence -> Bool
== :: Sequence -> Sequence -> Bool
$c/= :: Sequence -> Sequence -> Bool
/= :: 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 = Sequence -> IO Sequence
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: Sequence -> IO ()
boxedPtrFree = \Sequence
_x -> () -> IO ()
forall a. a -> IO a
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_ = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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_
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceAppend" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceAppend"
})
#endif
foreign import ccall "g_sequence_foreach" g_sequence_foreach ::
Ptr Sequence ->
FunPtr GLib.Callbacks.C_Func ->
Ptr () ->
IO ()
sequenceForeach ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> GLib.Callbacks.Func
-> m ()
sequenceForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Func -> m ()
sequenceForeach Sequence
seq Func
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_Func
func' <- C_Func -> IO (FunPtr C_Func)
GLib.Callbacks.mk_Func (Maybe (Ptr (FunPtr C_Func)) -> C_Func -> C_Func
GLib.Callbacks.wrap_Func Maybe (Ptr (FunPtr C_Func))
forall a. Maybe a
Nothing (Func -> C_Func
GLib.Callbacks.drop_closures_Func Func
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Sequence -> FunPtr C_Func -> Func
g_sequence_foreach Ptr Sequence
seq' FunPtr C_Func
func' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_Func -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_Func
func'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SequenceForeachMethodInfo
instance (signature ~ (GLib.Callbacks.Func -> m ()), MonadIO m) => O.OverloadedMethod SequenceForeachMethodInfo Sequence signature where
overloadedMethod = sequenceForeach
instance O.OverloadedMethodInfo SequenceForeachMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceForeach",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceForeach"
})
#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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
Ptr Sequence -> IO ()
g_sequence_free Ptr Sequence
seq'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
() -> IO ()
forall a. a -> IO a
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.30/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 = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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'
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetBeginIter" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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.30/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 = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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'
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetEndIter" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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.30/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 = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceGetIterAtPos" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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.30/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 = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
Int32 -> IO Int32
forall a. a -> IO a
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.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceGetLength"
})
#endif
foreign import ccall "g_sequence_insert_sorted" g_sequence_insert_sorted ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceInsertSorted ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.CompareDataFunc
-> m GLib.SequenceIter.SequenceIter
sequenceInsertSorted :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> CompareDataFunc -> m SequenceIter
sequenceInsertSorted Sequence
seq Ptr ()
data_ CompareDataFunc
cmpFunc = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_CompareDataFunc
cmpFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_insert_sorted Ptr Sequence
seq' Ptr ()
data_ FunPtr C_CompareDataFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceInsertSorted" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
cmpFunc'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceInsertSortedMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.CompareDataFunc -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceInsertSortedMethodInfo Sequence signature where
overloadedMethod = sequenceInsertSorted
instance O.OverloadedMethodInfo SequenceInsertSortedMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceInsertSorted",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceInsertSorted"
})
#endif
foreign import ccall "g_sequence_insert_sorted_iter" g_sequence_insert_sorted_iter ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_SequenceIterCompareFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceInsertSortedIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.SequenceIterCompareFunc
-> m GLib.SequenceIter.SequenceIter
sequenceInsertSortedIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> SequenceIterCompareFunc -> m SequenceIter
sequenceInsertSortedIter Sequence
seq Ptr ()
data_ SequenceIterCompareFunc
iterCmp = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_SequenceIterCompareFunc
iterCmp' <- C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
GLib.Callbacks.mk_SequenceIterCompareFunc (Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
-> SequenceIterCompareFunc_WithClosures
-> C_SequenceIterCompareFunc
GLib.Callbacks.wrap_SequenceIterCompareFunc Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
forall a. Maybe a
Nothing (SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
GLib.Callbacks.drop_closures_SequenceIterCompareFunc SequenceIterCompareFunc
iterCmp))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_SequenceIterCompareFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_insert_sorted_iter Ptr Sequence
seq' Ptr ()
data_ FunPtr C_SequenceIterCompareFunc
iterCmp' Ptr ()
forall a. Ptr a
cmpData
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceInsertSortedIter" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SequenceIterCompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SequenceIterCompareFunc
iterCmp'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceInsertSortedIterMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.SequenceIterCompareFunc -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceInsertSortedIterMethodInfo Sequence signature where
overloadedMethod = sequenceInsertSortedIter
instance O.OverloadedMethodInfo SequenceInsertSortedIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceInsertSortedIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceInsertSortedIter"
})
#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 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
Bool -> IO Bool
forall a. a -> IO a
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.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceIsEmpty"
})
#endif
foreign import ccall "g_sequence_lookup" g_sequence_lookup ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceLookup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.CompareDataFunc
-> m (Maybe GLib.SequenceIter.SequenceIter)
sequenceLookup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> CompareDataFunc -> m (Maybe SequenceIter)
sequenceLookup Sequence
seq Ptr ()
data_ CompareDataFunc
cmpFunc = IO (Maybe SequenceIter) -> m (Maybe SequenceIter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SequenceIter) -> m (Maybe SequenceIter))
-> IO (Maybe SequenceIter) -> m (Maybe SequenceIter)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_CompareDataFunc
cmpFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_lookup Ptr Sequence
seq' Ptr ()
data_ FunPtr C_CompareDataFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Maybe SequenceIter
maybeResult <- Ptr SequenceIter
-> (Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SequenceIter
result ((Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter))
-> (Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter)
forall a b. (a -> b) -> a -> b
$ \Ptr SequenceIter
result' -> do
SequenceIter
result'' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result'
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result''
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
cmpFunc'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
Maybe SequenceIter -> IO (Maybe SequenceIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SequenceIter
maybeResult
#if defined(ENABLE_OVERLOADING)
data SequenceLookupMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.CompareDataFunc -> m (Maybe GLib.SequenceIter.SequenceIter)), MonadIO m) => O.OverloadedMethod SequenceLookupMethodInfo Sequence signature where
overloadedMethod = sequenceLookup
instance O.OverloadedMethodInfo SequenceLookupMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceLookup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceLookup"
})
#endif
foreign import ccall "g_sequence_lookup_iter" g_sequence_lookup_iter ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_SequenceIterCompareFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceLookupIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.SequenceIterCompareFunc
-> m (Maybe GLib.SequenceIter.SequenceIter)
sequenceLookupIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence
-> Ptr () -> SequenceIterCompareFunc -> m (Maybe SequenceIter)
sequenceLookupIter Sequence
seq Ptr ()
data_ SequenceIterCompareFunc
iterCmp = IO (Maybe SequenceIter) -> m (Maybe SequenceIter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SequenceIter) -> m (Maybe SequenceIter))
-> IO (Maybe SequenceIter) -> m (Maybe SequenceIter)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_SequenceIterCompareFunc
iterCmp' <- C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
GLib.Callbacks.mk_SequenceIterCompareFunc (Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
-> SequenceIterCompareFunc_WithClosures
-> C_SequenceIterCompareFunc
GLib.Callbacks.wrap_SequenceIterCompareFunc Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
forall a. Maybe a
Nothing (SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
GLib.Callbacks.drop_closures_SequenceIterCompareFunc SequenceIterCompareFunc
iterCmp))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_SequenceIterCompareFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_lookup_iter Ptr Sequence
seq' Ptr ()
data_ FunPtr C_SequenceIterCompareFunc
iterCmp' Ptr ()
forall a. Ptr a
cmpData
Maybe SequenceIter
maybeResult <- Ptr SequenceIter
-> (Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SequenceIter
result ((Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter))
-> (Ptr SequenceIter -> IO SequenceIter) -> IO (Maybe SequenceIter)
forall a b. (a -> b) -> a -> b
$ \Ptr SequenceIter
result' -> do
SequenceIter
result'' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result'
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result''
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SequenceIterCompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SequenceIterCompareFunc
iterCmp'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
Maybe SequenceIter -> IO (Maybe SequenceIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SequenceIter
maybeResult
#if defined(ENABLE_OVERLOADING)
data SequenceLookupIterMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.SequenceIterCompareFunc -> m (Maybe GLib.SequenceIter.SequenceIter)), MonadIO m) => O.OverloadedMethod SequenceLookupIterMethodInfo Sequence signature where
overloadedMethod = sequenceLookupIter
instance O.OverloadedMethodInfo SequenceLookupIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceLookupIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceLookupIter"
})
#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_ = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
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_
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequencePrepend" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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.30/docs/GI-GLib-Structs-Sequence.html#v:sequencePrepend"
})
#endif
foreign import ccall "g_sequence_search" g_sequence_search ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceSearch ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.CompareDataFunc
-> m GLib.SequenceIter.SequenceIter
sequenceSearch :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> CompareDataFunc -> m SequenceIter
sequenceSearch Sequence
seq Ptr ()
data_ CompareDataFunc
cmpFunc = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_CompareDataFunc
cmpFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_search Ptr Sequence
seq' Ptr ()
data_ FunPtr C_CompareDataFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceSearch" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
cmpFunc'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceSearchMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.CompareDataFunc -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceSearchMethodInfo Sequence signature where
overloadedMethod = sequenceSearch
instance O.OverloadedMethodInfo SequenceSearchMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceSearch",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceSearch"
})
#endif
foreign import ccall "g_sequence_search_iter" g_sequence_search_iter ::
Ptr Sequence ->
Ptr () ->
FunPtr GLib.Callbacks.C_SequenceIterCompareFunc ->
Ptr () ->
IO (Ptr GLib.SequenceIter.SequenceIter)
sequenceSearchIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> Ptr ()
-> GLib.Callbacks.SequenceIterCompareFunc
-> m GLib.SequenceIter.SequenceIter
sequenceSearchIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> Ptr () -> SequenceIterCompareFunc -> m SequenceIter
sequenceSearchIter Sequence
seq Ptr ()
data_ SequenceIterCompareFunc
iterCmp = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_SequenceIterCompareFunc
iterCmp' <- C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
GLib.Callbacks.mk_SequenceIterCompareFunc (Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
-> SequenceIterCompareFunc_WithClosures
-> C_SequenceIterCompareFunc
GLib.Callbacks.wrap_SequenceIterCompareFunc Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
forall a. Maybe a
Nothing (SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
GLib.Callbacks.drop_closures_SequenceIterCompareFunc SequenceIterCompareFunc
iterCmp))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter
result <- Ptr Sequence
-> Ptr ()
-> FunPtr C_SequenceIterCompareFunc
-> Ptr ()
-> IO (Ptr SequenceIter)
g_sequence_search_iter Ptr Sequence
seq' Ptr ()
data_ FunPtr C_SequenceIterCompareFunc
iterCmp' Ptr ()
forall a. Ptr a
cmpData
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceSearchIter" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SequenceIterCompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SequenceIterCompareFunc
iterCmp'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
SequenceIter -> IO SequenceIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SequenceIter
result'
#if defined(ENABLE_OVERLOADING)
data SequenceSearchIterMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.SequenceIterCompareFunc -> m GLib.SequenceIter.SequenceIter), MonadIO m) => O.OverloadedMethod SequenceSearchIterMethodInfo Sequence signature where
overloadedMethod = sequenceSearchIter
instance O.OverloadedMethodInfo SequenceSearchIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceSearchIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceSearchIter"
})
#endif
foreign import ccall "g_sequence_sort" g_sequence_sort ::
Ptr Sequence ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO ()
sequenceSort ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> GLib.Callbacks.CompareDataFunc
-> m ()
sequenceSort :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> CompareDataFunc -> m ()
sequenceSort Sequence
seq CompareDataFunc
cmpFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_CompareDataFunc
cmpFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr Sequence -> FunPtr C_CompareDataFunc -> Func
g_sequence_sort Ptr Sequence
seq' FunPtr C_CompareDataFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
cmpFunc'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SequenceSortMethodInfo
instance (signature ~ (GLib.Callbacks.CompareDataFunc -> m ()), MonadIO m) => O.OverloadedMethod SequenceSortMethodInfo Sequence signature where
overloadedMethod = sequenceSort
instance O.OverloadedMethodInfo SequenceSortMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceSort",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceSort"
})
#endif
foreign import ccall "g_sequence_sort_iter" g_sequence_sort_iter ::
Ptr Sequence ->
FunPtr GLib.Callbacks.C_SequenceIterCompareFunc ->
Ptr () ->
IO ()
sequenceSortIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sequence
-> GLib.Callbacks.SequenceIterCompareFunc
-> m ()
sequenceSortIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sequence -> SequenceIterCompareFunc -> m ()
sequenceSortIter Sequence
seq SequenceIterCompareFunc
cmpFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sequence
seq' <- Sequence -> IO (Ptr Sequence)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sequence
seq
FunPtr C_SequenceIterCompareFunc
cmpFunc' <- C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
GLib.Callbacks.mk_SequenceIterCompareFunc (Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
-> SequenceIterCompareFunc_WithClosures
-> C_SequenceIterCompareFunc
GLib.Callbacks.wrap_SequenceIterCompareFunc Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
forall a. Maybe a
Nothing (SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
GLib.Callbacks.drop_closures_SequenceIterCompareFunc SequenceIterCompareFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr Sequence -> FunPtr C_SequenceIterCompareFunc -> Func
g_sequence_sort_iter Ptr Sequence
seq' FunPtr C_SequenceIterCompareFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SequenceIterCompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SequenceIterCompareFunc
cmpFunc'
Sequence -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sequence
seq
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SequenceSortIterMethodInfo
instance (signature ~ (GLib.Callbacks.SequenceIterCompareFunc -> m ()), MonadIO m) => O.OverloadedMethod SequenceSortIterMethodInfo Sequence signature where
overloadedMethod = sequenceSortIter
instance O.OverloadedMethodInfo SequenceSortIterMethodInfo Sequence where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Sequence.sequenceSortIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-Sequence.html#v:sequenceSortIter"
})
#endif
foreign import ccall "g_sequence_foreach_range" g_sequence_foreach_range ::
Ptr GLib.SequenceIter.SequenceIter ->
Ptr GLib.SequenceIter.SequenceIter ->
FunPtr GLib.Callbacks.C_Func ->
Ptr () ->
IO ()
sequenceForeachRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.SequenceIter.SequenceIter
-> GLib.Callbacks.Func
-> m ()
sequenceForeachRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIter -> Func -> m ()
sequenceForeachRange SequenceIter
begin SequenceIter
end Func
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
begin' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
end
FunPtr C_Func
func' <- C_Func -> IO (FunPtr C_Func)
GLib.Callbacks.mk_Func (Maybe (Ptr (FunPtr C_Func)) -> C_Func -> C_Func
GLib.Callbacks.wrap_Func Maybe (Ptr (FunPtr C_Func))
forall a. Maybe a
Nothing (Func -> C_Func
GLib.Callbacks.drop_closures_Func Func
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter -> Ptr SequenceIter -> FunPtr C_Func -> Func
g_sequence_foreach_range Ptr SequenceIter
begin' Ptr SequenceIter
end' FunPtr C_Func
func' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_Func -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_Func
func'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#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 = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr ()
result <- Ptr SequenceIter -> IO (Ptr ())
g_sequence_get Ptr SequenceIter
iter'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
Ptr () -> IO (Ptr ())
forall a. a -> IO a
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_ = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
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_
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceInsertBefore" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
src' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
src
Ptr SequenceIter
dest' <- SequenceIter -> IO (Ptr SequenceIter)
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'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
src
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
dest
() -> IO ()
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
dest' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
dest
Ptr SequenceIter
begin' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- SequenceIter -> IO (Ptr SequenceIter)
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'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
dest
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
() -> IO ()
forall a. a -> IO a
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 = IO SequenceIter -> m SequenceIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SequenceIter -> m SequenceIter)
-> IO SequenceIter -> m SequenceIter
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
begin' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- SequenceIter -> IO (Ptr SequenceIter)
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'
Text -> Ptr SequenceIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sequenceRangeGetMidpoint" Ptr SequenceIter
result
SequenceIter
result' <- ((ManagedPtr SequenceIter -> SequenceIter)
-> Ptr SequenceIter -> IO SequenceIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SequenceIter -> SequenceIter
GLib.SequenceIter.SequenceIter) Ptr SequenceIter
result
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
SequenceIter -> IO SequenceIter
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr SequenceIter -> IO ()
g_sequence_remove Ptr SequenceIter
iter'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
() -> IO ()
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
begin' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
begin
Ptr SequenceIter
end' <- SequenceIter -> IO (Ptr SequenceIter)
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'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
begin
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
end
() -> IO ()
forall a. a -> IO a
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_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
Ptr SequenceIter -> Func
g_sequence_set Ptr SequenceIter
iter' Ptr ()
data_
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_sort_changed" g_sequence_sort_changed ::
Ptr GLib.SequenceIter.SequenceIter ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO ()
sequenceSortChanged ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.Callbacks.CompareDataFunc
-> m ()
sequenceSortChanged :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> CompareDataFunc -> m ()
sequenceSortChanged SequenceIter
iter CompareDataFunc
cmpFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
FunPtr C_CompareDataFunc
cmpFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
cmpFunc))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter -> FunPtr C_CompareDataFunc -> Func
g_sequence_sort_changed Ptr SequenceIter
iter' FunPtr C_CompareDataFunc
cmpFunc' Ptr ()
forall a. Ptr a
cmpData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
cmpFunc'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_sequence_sort_changed_iter" g_sequence_sort_changed_iter ::
Ptr GLib.SequenceIter.SequenceIter ->
FunPtr GLib.Callbacks.C_SequenceIterCompareFunc ->
Ptr () ->
IO ()
sequenceSortChangedIter ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.SequenceIter.SequenceIter
-> GLib.Callbacks.SequenceIterCompareFunc
-> m ()
sequenceSortChangedIter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
SequenceIter -> SequenceIterCompareFunc -> m ()
sequenceSortChangedIter SequenceIter
iter SequenceIterCompareFunc
iterCmp = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
iter' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
iter
FunPtr C_SequenceIterCompareFunc
iterCmp' <- C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
GLib.Callbacks.mk_SequenceIterCompareFunc (Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
-> SequenceIterCompareFunc_WithClosures
-> C_SequenceIterCompareFunc
GLib.Callbacks.wrap_SequenceIterCompareFunc Maybe (Ptr (FunPtr C_SequenceIterCompareFunc))
forall a. Maybe a
Nothing (SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
GLib.Callbacks.drop_closures_SequenceIterCompareFunc SequenceIterCompareFunc
iterCmp))
let cmpData :: Ptr a
cmpData = Ptr a
forall a. Ptr a
nullPtr
Ptr SequenceIter -> FunPtr C_SequenceIterCompareFunc -> Func
g_sequence_sort_changed_iter Ptr SequenceIter
iter' FunPtr C_SequenceIterCompareFunc
iterCmp' Ptr ()
forall a. Ptr a
cmpData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_SequenceIterCompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SequenceIterCompareFunc
iterCmp'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
iter
() -> IO ()
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SequenceIter
a' <- SequenceIter -> IO (Ptr SequenceIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SequenceIter
a
Ptr SequenceIter
b' <- SequenceIter -> IO (Ptr SequenceIter)
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'
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
a
SequenceIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SequenceIter
b
() -> IO ()
forall a. a -> IO a
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 "foreach" o = SequenceForeachMethodInfo
ResolveSequenceMethod "free" o = SequenceFreeMethodInfo
ResolveSequenceMethod "insertSorted" o = SequenceInsertSortedMethodInfo
ResolveSequenceMethod "insertSortedIter" o = SequenceInsertSortedIterMethodInfo
ResolveSequenceMethod "isEmpty" o = SequenceIsEmptyMethodInfo
ResolveSequenceMethod "lookup" o = SequenceLookupMethodInfo
ResolveSequenceMethod "lookupIter" o = SequenceLookupIterMethodInfo
ResolveSequenceMethod "prepend" o = SequencePrependMethodInfo
ResolveSequenceMethod "search" o = SequenceSearchMethodInfo
ResolveSequenceMethod "searchIter" o = SequenceSearchIterMethodInfo
ResolveSequenceMethod "sort" o = SequenceSortMethodInfo
ResolveSequenceMethod "sortIter" o = SequenceSortIterMethodInfo
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