{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Queue
(
Queue(..) ,
newZeroQueue ,
#if defined(ENABLE_OVERLOADING)
ResolveQueueMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
QueueClearMethodInfo ,
#endif
queueClear ,
#if defined(ENABLE_OVERLOADING)
QueueClearFullMethodInfo ,
#endif
queueClearFull ,
#if defined(ENABLE_OVERLOADING)
QueueFreeMethodInfo ,
#endif
queueFree ,
#if defined(ENABLE_OVERLOADING)
QueueFreeFullMethodInfo ,
#endif
queueFreeFull ,
#if defined(ENABLE_OVERLOADING)
QueueGetLengthMethodInfo ,
#endif
queueGetLength ,
#if defined(ENABLE_OVERLOADING)
QueueIndexMethodInfo ,
#endif
queueIndex ,
#if defined(ENABLE_OVERLOADING)
QueueInitMethodInfo ,
#endif
queueInit ,
#if defined(ENABLE_OVERLOADING)
QueueIsEmptyMethodInfo ,
#endif
queueIsEmpty ,
#if defined(ENABLE_OVERLOADING)
QueuePeekHeadMethodInfo ,
#endif
queuePeekHead ,
#if defined(ENABLE_OVERLOADING)
QueuePeekNthMethodInfo ,
#endif
queuePeekNth ,
#if defined(ENABLE_OVERLOADING)
QueuePeekTailMethodInfo ,
#endif
queuePeekTail ,
#if defined(ENABLE_OVERLOADING)
QueuePopHeadMethodInfo ,
#endif
queuePopHead ,
#if defined(ENABLE_OVERLOADING)
QueuePopNthMethodInfo ,
#endif
queuePopNth ,
#if defined(ENABLE_OVERLOADING)
QueuePopTailMethodInfo ,
#endif
queuePopTail ,
#if defined(ENABLE_OVERLOADING)
QueuePushHeadMethodInfo ,
#endif
queuePushHead ,
#if defined(ENABLE_OVERLOADING)
QueuePushNthMethodInfo ,
#endif
queuePushNth ,
#if defined(ENABLE_OVERLOADING)
QueuePushTailMethodInfo ,
#endif
queuePushTail ,
#if defined(ENABLE_OVERLOADING)
QueueRemoveMethodInfo ,
#endif
queueRemove ,
#if defined(ENABLE_OVERLOADING)
QueueRemoveAllMethodInfo ,
#endif
queueRemoveAll ,
#if defined(ENABLE_OVERLOADING)
QueueReverseMethodInfo ,
#endif
queueReverse ,
clearQueueHead ,
getQueueHead ,
#if defined(ENABLE_OVERLOADING)
queue_head ,
#endif
setQueueHead ,
getQueueLength ,
#if defined(ENABLE_OVERLOADING)
queue_length ,
#endif
setQueueLength ,
clearQueueTail ,
getQueueTail ,
#if defined(ENABLE_OVERLOADING)
queue_tail ,
#endif
setQueueTail ,
) 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.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 GI.GLib.Callbacks as GLib.Callbacks
newtype Queue = Queue (SP.ManagedPtr Queue)
deriving (Queue -> Queue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Queue -> Queue -> Bool
$c/= :: Queue -> Queue -> Bool
== :: Queue -> Queue -> Bool
$c== :: Queue -> Queue -> Bool
Eq)
instance SP.ManagedPtrNewtype Queue where
toManagedPtr :: Queue -> ManagedPtr Queue
toManagedPtr (Queue ManagedPtr Queue
p) = ManagedPtr Queue
p
instance BoxedPtr Queue where
boxedPtrCopy :: Queue -> IO Queue
boxedPtrCopy = \Queue
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Queue
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
12 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Queue -> Queue
Queue)
boxedPtrFree :: Queue -> IO ()
boxedPtrFree = \Queue
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Queue
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Queue where
boxedPtrCalloc :: IO (Ptr Queue)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
12
newZeroQueue :: MonadIO m => m Queue
newZeroQueue :: forall (m :: * -> *). MonadIO m => m Queue
newZeroQueue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Queue -> Queue
Queue
instance tag ~ 'AttrSet => Constructible Queue tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Queue -> Queue) -> [AttrOp Queue tag] -> m Queue
new ManagedPtr Queue -> Queue
_ [AttrOp Queue tag]
attrs = do
Queue
o <- forall (m :: * -> *). MonadIO m => m Queue
newZeroQueue
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Queue
o [AttrOp Queue tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return Queue
o
getQueueHead :: MonadIO m => Queue -> m ([Ptr ()])
getQueueHead :: forall (m :: * -> *). MonadIO m => Queue -> m [Ptr ()]
getQueueHead Queue
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
Ptr (GList (Ptr ()))
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr (GList (Ptr ())))
[Ptr ()]
val' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ()))
val
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'
setQueueHead :: MonadIO m => Queue -> Ptr (GList (Ptr ())) -> m ()
setQueueHead :: forall (m :: * -> *).
MonadIO m =>
Queue -> Ptr (GList (Ptr ())) -> m ()
setQueueHead Queue
s Ptr (GList (Ptr ()))
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr (GList (Ptr ()))
val :: Ptr (GList (Ptr ())))
clearQueueHead :: MonadIO m => Queue -> m ()
clearQueueHead :: forall (m :: * -> *). MonadIO m => Queue -> m ()
clearQueueHead Queue
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr (GList (Ptr ())))
#if defined(ENABLE_OVERLOADING)
data QueueHeadFieldInfo
instance AttrInfo QueueHeadFieldInfo where
type AttrBaseTypeConstraint QueueHeadFieldInfo = (~) Queue
type AttrAllowedOps QueueHeadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint QueueHeadFieldInfo = (~) (Ptr (GList (Ptr ())))
type AttrTransferTypeConstraint QueueHeadFieldInfo = (~)(Ptr (GList (Ptr ())))
type AttrTransferType QueueHeadFieldInfo = (Ptr (GList (Ptr ())))
type AttrGetType QueueHeadFieldInfo = [Ptr ()]
type AttrLabel QueueHeadFieldInfo = "head"
type AttrOrigin QueueHeadFieldInfo = Queue
attrGet = getQueueHead
attrSet = setQueueHead
attrConstruct = undefined
attrClear = clearQueueHead
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.head"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#g:attr:head"
})
queue_head :: AttrLabelProxy "head"
queue_head = AttrLabelProxy
#endif
getQueueTail :: MonadIO m => Queue -> m ([Ptr ()])
getQueueTail :: forall (m :: * -> *). MonadIO m => Queue -> m [Ptr ()]
getQueueTail Queue
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
Ptr (GList (Ptr ()))
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr (GList (Ptr ())))
[Ptr ()]
val' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ()))
val
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'
setQueueTail :: MonadIO m => Queue -> Ptr (GList (Ptr ())) -> m ()
setQueueTail :: forall (m :: * -> *).
MonadIO m =>
Queue -> Ptr (GList (Ptr ())) -> m ()
setQueueTail Queue
s Ptr (GList (Ptr ()))
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr (GList (Ptr ()))
val :: Ptr (GList (Ptr ())))
clearQueueTail :: MonadIO m => Queue -> m ()
clearQueueTail :: forall (m :: * -> *). MonadIO m => Queue -> m ()
clearQueueTail Queue
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr (GList (Ptr ())))
#if defined(ENABLE_OVERLOADING)
data QueueTailFieldInfo
instance AttrInfo QueueTailFieldInfo where
type AttrBaseTypeConstraint QueueTailFieldInfo = (~) Queue
type AttrAllowedOps QueueTailFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint QueueTailFieldInfo = (~) (Ptr (GList (Ptr ())))
type AttrTransferTypeConstraint QueueTailFieldInfo = (~)(Ptr (GList (Ptr ())))
type AttrTransferType QueueTailFieldInfo = (Ptr (GList (Ptr ())))
type AttrGetType QueueTailFieldInfo = [Ptr ()]
type AttrLabel QueueTailFieldInfo = "tail"
type AttrOrigin QueueTailFieldInfo = Queue
attrGet = getQueueTail
attrSet = setQueueTail
attrConstruct = undefined
attrClear = clearQueueTail
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.tail"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#g:attr:tail"
})
queue_tail :: AttrLabelProxy "tail"
queue_tail = AttrLabelProxy
#endif
getQueueLength :: MonadIO m => Queue -> m Word32
getQueueLength :: forall (m :: * -> *). MonadIO m => Queue -> m Word32
getQueueLength Queue
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setQueueLength :: MonadIO m => Queue -> Word32 -> m ()
setQueueLength :: forall (m :: * -> *). MonadIO m => Queue -> Word32 -> m ()
setQueueLength Queue
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Queue
s forall a b. (a -> b) -> a -> b
$ \Ptr Queue
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Queue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data QueueLengthFieldInfo
instance AttrInfo QueueLengthFieldInfo where
type AttrBaseTypeConstraint QueueLengthFieldInfo = (~) Queue
type AttrAllowedOps QueueLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint QueueLengthFieldInfo = (~) Word32
type AttrTransferTypeConstraint QueueLengthFieldInfo = (~)Word32
type AttrTransferType QueueLengthFieldInfo = Word32
type AttrGetType QueueLengthFieldInfo = Word32
type AttrLabel QueueLengthFieldInfo = "length"
type AttrOrigin QueueLengthFieldInfo = Queue
attrGet = getQueueLength
attrSet = setQueueLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.length"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#g:attr:length"
})
queue_length :: AttrLabelProxy "length"
queue_length = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Queue
type instance O.AttributeList Queue = QueueAttributeList
type QueueAttributeList = ('[ '("head", QueueHeadFieldInfo), '("tail", QueueTailFieldInfo), '("length", QueueLengthFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_queue_clear" g_queue_clear ::
Ptr Queue ->
IO ()
queueClear ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m ()
queueClear :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Queue -> m ()
queueClear Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> IO ()
g_queue_clear Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod QueueClearMethodInfo Queue signature where
overloadedMethod = queueClear
instance O.OverloadedMethodInfo QueueClearMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueClear",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueClear"
})
#endif
foreign import ccall "g_queue_clear_full" g_queue_clear_full ::
Ptr Queue ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
queueClearFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Maybe (GLib.Callbacks.DestroyNotify)
-> m ()
queueClearFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Maybe DestroyNotify -> m ()
queueClearFull Queue
queue Maybe DestroyNotify
freeFunc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
FunPtr DestroyNotify
maybeFreeFunc <- case Maybe DestroyNotify
freeFunc of
Maybe DestroyNotify
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just DestroyNotify
jFreeFunc -> do
Ptr (FunPtr DestroyNotify)
ptrfreeFunc <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
jFreeFunc' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrfreeFunc) DestroyNotify
jFreeFunc)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrfreeFunc FunPtr DestroyNotify
jFreeFunc'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr DestroyNotify
jFreeFunc'
Ptr Queue -> FunPtr DestroyNotify -> IO ()
g_queue_clear_full Ptr Queue
queue' FunPtr DestroyNotify
maybeFreeFunc
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueClearFullMethodInfo
instance (signature ~ (Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m) => O.OverloadedMethod QueueClearFullMethodInfo Queue signature where
overloadedMethod = queueClearFull
instance O.OverloadedMethodInfo QueueClearFullMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueClearFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueClearFull"
})
#endif
foreign import ccall "g_queue_free" g_queue_free ::
Ptr Queue ->
IO ()
queueFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m ()
queueFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Queue -> m ()
queueFree Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> IO ()
g_queue_free Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod QueueFreeMethodInfo Queue signature where
overloadedMethod = queueFree
instance O.OverloadedMethodInfo QueueFreeMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueFree"
})
#endif
foreign import ccall "g_queue_free_full" g_queue_free_full ::
Ptr Queue ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
queueFreeFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> GLib.Callbacks.DestroyNotify
-> m ()
queueFreeFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> DestroyNotify -> m ()
queueFreeFull Queue
queue DestroyNotify
freeFunc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr (FunPtr DestroyNotify)
ptrfreeFunc <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
freeFunc' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrfreeFunc) DestroyNotify
freeFunc)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrfreeFunc FunPtr DestroyNotify
freeFunc'
Ptr Queue -> FunPtr DestroyNotify -> IO ()
g_queue_free_full Ptr Queue
queue' FunPtr DestroyNotify
freeFunc'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueFreeFullMethodInfo
instance (signature ~ (GLib.Callbacks.DestroyNotify -> m ()), MonadIO m) => O.OverloadedMethod QueueFreeFullMethodInfo Queue signature where
overloadedMethod = queueFreeFull
instance O.OverloadedMethodInfo QueueFreeFullMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueFreeFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueFreeFull"
})
#endif
foreign import ccall "g_queue_get_length" g_queue_get_length ::
Ptr Queue ->
IO Word32
queueGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m Word32
queueGetLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> m Word32
queueGetLength Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Word32
result <- Ptr Queue -> IO Word32
g_queue_get_length Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data QueueGetLengthMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod QueueGetLengthMethodInfo Queue signature where
overloadedMethod = queueGetLength
instance O.OverloadedMethodInfo QueueGetLengthMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueGetLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueGetLength"
})
#endif
foreign import ccall "g_queue_index" g_queue_index ::
Ptr Queue ->
Ptr () ->
IO Int32
queueIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> m Int32
queueIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> m Int32
queueIndex Queue
queue Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Int32
result <- Ptr Queue -> Ptr () -> IO Int32
g_queue_index Ptr Queue
queue' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data QueueIndexMethodInfo
instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.OverloadedMethod QueueIndexMethodInfo Queue signature where
overloadedMethod = queueIndex
instance O.OverloadedMethodInfo QueueIndexMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueIndex"
})
#endif
foreign import ccall "g_queue_init" g_queue_init ::
Ptr Queue ->
IO ()
queueInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m ()
queueInit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Queue -> m ()
queueInit Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> IO ()
g_queue_init Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueInitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod QueueInitMethodInfo Queue signature where
overloadedMethod = queueInit
instance O.OverloadedMethodInfo QueueInitMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueInit"
})
#endif
foreign import ccall "g_queue_is_empty" g_queue_is_empty ::
Ptr Queue ->
IO CInt
queueIsEmpty ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m Bool
queueIsEmpty :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Queue -> m Bool
queueIsEmpty Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
CInt
result <- Ptr Queue -> IO CInt
g_queue_is_empty Ptr Queue
queue'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data QueueIsEmptyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod QueueIsEmptyMethodInfo Queue signature where
overloadedMethod = queueIsEmpty
instance O.OverloadedMethodInfo QueueIsEmptyMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueIsEmpty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueIsEmpty"
})
#endif
foreign import ccall "g_queue_peek_head" g_queue_peek_head ::
Ptr Queue ->
IO (Ptr ())
queuePeekHead ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m (Ptr ())
queuePeekHead :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> m (Ptr ())
queuePeekHead Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> IO (Ptr ())
g_queue_peek_head Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePeekHeadMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePeekHeadMethodInfo Queue signature where
overloadedMethod = queuePeekHead
instance O.OverloadedMethodInfo QueuePeekHeadMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePeekHead",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePeekHead"
})
#endif
foreign import ccall "g_queue_peek_nth" g_queue_peek_nth ::
Ptr Queue ->
Word32 ->
IO (Ptr ())
queuePeekNth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Word32
-> m (Ptr ())
queuePeekNth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Word32 -> m (Ptr ())
queuePeekNth Queue
queue Word32
n = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> Word32 -> IO (Ptr ())
g_queue_peek_nth Ptr Queue
queue' Word32
n
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePeekNthMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePeekNthMethodInfo Queue signature where
overloadedMethod = queuePeekNth
instance O.OverloadedMethodInfo QueuePeekNthMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePeekNth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePeekNth"
})
#endif
foreign import ccall "g_queue_peek_tail" g_queue_peek_tail ::
Ptr Queue ->
IO (Ptr ())
queuePeekTail ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m (Ptr ())
queuePeekTail :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> m (Ptr ())
queuePeekTail Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> IO (Ptr ())
g_queue_peek_tail Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePeekTailMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePeekTailMethodInfo Queue signature where
overloadedMethod = queuePeekTail
instance O.OverloadedMethodInfo QueuePeekTailMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePeekTail",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePeekTail"
})
#endif
foreign import ccall "g_queue_pop_head" g_queue_pop_head ::
Ptr Queue ->
IO (Ptr ())
queuePopHead ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m (Ptr ())
queuePopHead :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> m (Ptr ())
queuePopHead Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> IO (Ptr ())
g_queue_pop_head Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePopHeadMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePopHeadMethodInfo Queue signature where
overloadedMethod = queuePopHead
instance O.OverloadedMethodInfo QueuePopHeadMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePopHead",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePopHead"
})
#endif
foreign import ccall "g_queue_pop_nth" g_queue_pop_nth ::
Ptr Queue ->
Word32 ->
IO (Ptr ())
queuePopNth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Word32
-> m (Ptr ())
queuePopNth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Word32 -> m (Ptr ())
queuePopNth Queue
queue Word32
n = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> Word32 -> IO (Ptr ())
g_queue_pop_nth Ptr Queue
queue' Word32
n
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePopNthMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePopNthMethodInfo Queue signature where
overloadedMethod = queuePopNth
instance O.OverloadedMethodInfo QueuePopNthMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePopNth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePopNth"
})
#endif
foreign import ccall "g_queue_pop_tail" g_queue_pop_tail ::
Ptr Queue ->
IO (Ptr ())
queuePopTail ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m (Ptr ())
queuePopTail :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> m (Ptr ())
queuePopTail Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr ()
result <- Ptr Queue -> IO (Ptr ())
g_queue_pop_tail Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data QueuePopTailMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod QueuePopTailMethodInfo Queue signature where
overloadedMethod = queuePopTail
instance O.OverloadedMethodInfo QueuePopTailMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePopTail",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePopTail"
})
#endif
foreign import ccall "g_queue_push_head" g_queue_push_head ::
Ptr Queue ->
Ptr () ->
IO ()
queuePushHead ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> m ()
queuePushHead :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> m ()
queuePushHead Queue
queue Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> DestroyNotify
g_queue_push_head Ptr Queue
queue' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueuePushHeadMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.OverloadedMethod QueuePushHeadMethodInfo Queue signature where
overloadedMethod = queuePushHead
instance O.OverloadedMethodInfo QueuePushHeadMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePushHead",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePushHead"
})
#endif
foreign import ccall "g_queue_push_nth" g_queue_push_nth ::
Ptr Queue ->
Ptr () ->
Int32 ->
IO ()
queuePushNth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> Int32
-> m ()
queuePushNth :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> Int32 -> m ()
queuePushNth Queue
queue Ptr ()
data_ Int32
n = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> Ptr () -> Int32 -> IO ()
g_queue_push_nth Ptr Queue
queue' Ptr ()
data_ Int32
n
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueuePushNthMethodInfo
instance (signature ~ (Ptr () -> Int32 -> m ()), MonadIO m) => O.OverloadedMethod QueuePushNthMethodInfo Queue signature where
overloadedMethod = queuePushNth
instance O.OverloadedMethodInfo QueuePushNthMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePushNth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePushNth"
})
#endif
foreign import ccall "g_queue_push_tail" g_queue_push_tail ::
Ptr Queue ->
Ptr () ->
IO ()
queuePushTail ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> m ()
queuePushTail :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> m ()
queuePushTail Queue
queue Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> DestroyNotify
g_queue_push_tail Ptr Queue
queue' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueuePushTailMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.OverloadedMethod QueuePushTailMethodInfo Queue signature where
overloadedMethod = queuePushTail
instance O.OverloadedMethodInfo QueuePushTailMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queuePushTail",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queuePushTail"
})
#endif
foreign import ccall "g_queue_remove" g_queue_remove ::
Ptr Queue ->
Ptr () ->
IO CInt
queueRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> m Bool
queueRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> m Bool
queueRemove Queue
queue Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
CInt
result <- Ptr Queue -> Ptr () -> IO CInt
g_queue_remove Ptr Queue
queue' Ptr ()
data_
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data QueueRemoveMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod QueueRemoveMethodInfo Queue signature where
overloadedMethod = queueRemove
instance O.OverloadedMethodInfo QueueRemoveMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueRemove"
})
#endif
foreign import ccall "g_queue_remove_all" g_queue_remove_all ::
Ptr Queue ->
Ptr () ->
IO Word32
queueRemoveAll ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> Ptr ()
-> m Word32
queueRemoveAll :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Queue -> Ptr () -> m Word32
queueRemoveAll Queue
queue Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Word32
result <- Ptr Queue -> Ptr () -> IO Word32
g_queue_remove_all Ptr Queue
queue' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data QueueRemoveAllMethodInfo
instance (signature ~ (Ptr () -> m Word32), MonadIO m) => O.OverloadedMethod QueueRemoveAllMethodInfo Queue signature where
overloadedMethod = queueRemoveAll
instance O.OverloadedMethodInfo QueueRemoveAllMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueRemoveAll",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueRemoveAll"
})
#endif
foreign import ccall "g_queue_reverse" g_queue_reverse ::
Ptr Queue ->
IO ()
queueReverse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Queue
-> m ()
queueReverse :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Queue -> m ()
queueReverse Queue
queue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Queue
queue' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Queue
queue
Ptr Queue -> IO ()
g_queue_reverse Ptr Queue
queue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Queue
queue
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data QueueReverseMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod QueueReverseMethodInfo Queue signature where
overloadedMethod = queueReverse
instance O.OverloadedMethodInfo QueueReverseMethodInfo Queue where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Queue.queueReverse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Queue.html#v:queueReverse"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveQueueMethod (t :: Symbol) (o :: *) :: * where
ResolveQueueMethod "clear" o = QueueClearMethodInfo
ResolveQueueMethod "clearFull" o = QueueClearFullMethodInfo
ResolveQueueMethod "free" o = QueueFreeMethodInfo
ResolveQueueMethod "freeFull" o = QueueFreeFullMethodInfo
ResolveQueueMethod "index" o = QueueIndexMethodInfo
ResolveQueueMethod "init" o = QueueInitMethodInfo
ResolveQueueMethod "isEmpty" o = QueueIsEmptyMethodInfo
ResolveQueueMethod "peekHead" o = QueuePeekHeadMethodInfo
ResolveQueueMethod "peekNth" o = QueuePeekNthMethodInfo
ResolveQueueMethod "peekTail" o = QueuePeekTailMethodInfo
ResolveQueueMethod "popHead" o = QueuePopHeadMethodInfo
ResolveQueueMethod "popNth" o = QueuePopNthMethodInfo
ResolveQueueMethod "popTail" o = QueuePopTailMethodInfo
ResolveQueueMethod "pushHead" o = QueuePushHeadMethodInfo
ResolveQueueMethod "pushNth" o = QueuePushNthMethodInfo
ResolveQueueMethod "pushTail" o = QueuePushTailMethodInfo
ResolveQueueMethod "remove" o = QueueRemoveMethodInfo
ResolveQueueMethod "removeAll" o = QueueRemoveAllMethodInfo
ResolveQueueMethod "reverse" o = QueueReverseMethodInfo
ResolveQueueMethod "getLength" o = QueueGetLengthMethodInfo
ResolveQueueMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveQueueMethod t Queue, O.OverloadedMethod info Queue p) => OL.IsLabel t (Queue -> 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 ~ ResolveQueueMethod t Queue, O.OverloadedMethod info Queue p, R.HasField t Queue p) => R.HasField t Queue p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveQueueMethod t Queue, O.OverloadedMethodInfo info Queue) => OL.IsLabel t (O.MethodProxy info Queue) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif