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

    Contains the public fields of a
    [Queue][glib-Double-ended-Queues].
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.GLib.Structs.Queue
        (

    -- * Exported types
        Queue(..)                               ,
        newZeroQueue                            ,
        noQueue                                 ,

     -- * Methods
    -- ** clear #method:clear#

    #if ENABLE_OVERLOADING
        QueueClearMethodInfo                    ,
    #endif
        queueClear                              ,

    -- ** clearFull #method:clearFull#

    #if ENABLE_OVERLOADING
        QueueClearFullMethodInfo                ,
    #endif
        queueClearFull                          ,

    -- ** free #method:free#

    #if ENABLE_OVERLOADING
        QueueFreeMethodInfo                     ,
    #endif
        queueFree                               ,

    -- ** freeFull #method:freeFull#

    #if ENABLE_OVERLOADING
        QueueFreeFullMethodInfo                 ,
    #endif
        queueFreeFull                           ,

    -- ** getLength #method:getLength#

    #if ENABLE_OVERLOADING
        QueueGetLengthMethodInfo                ,
    #endif
        queueGetLength                          ,

    -- ** index #method:index#

    #if ENABLE_OVERLOADING
        QueueIndexMethodInfo                    ,
    #endif
        queueIndex                              ,

    -- ** init #method:init#

    #if ENABLE_OVERLOADING
        QueueInitMethodInfo                     ,
    #endif
        queueInit                               ,

    -- ** isEmpty #method:isEmpty#

    #if ENABLE_OVERLOADING
        QueueIsEmptyMethodInfo                  ,
    #endif
        queueIsEmpty                            ,

    -- ** peekHead #method:peekHead#

    #if ENABLE_OVERLOADING
        QueuePeekHeadMethodInfo                 ,
    #endif
        queuePeekHead                           ,

    -- ** peekNth #method:peekNth#

    #if ENABLE_OVERLOADING
        QueuePeekNthMethodInfo                  ,
    #endif
        queuePeekNth                            ,

    -- ** peekTail #method:peekTail#

    #if ENABLE_OVERLOADING
        QueuePeekTailMethodInfo                 ,
    #endif
        queuePeekTail                           ,

    -- ** popHead #method:popHead#

    #if ENABLE_OVERLOADING
        QueuePopHeadMethodInfo                  ,
    #endif
        queuePopHead                            ,

    -- ** popNth #method:popNth#

    #if ENABLE_OVERLOADING
        QueuePopNthMethodInfo                   ,
    #endif
        queuePopNth                             ,

    -- ** popTail #method:popTail#

    #if ENABLE_OVERLOADING
        QueuePopTailMethodInfo                  ,
    #endif
        queuePopTail                            ,

    -- ** pushHead #method:pushHead#

    #if ENABLE_OVERLOADING
        QueuePushHeadMethodInfo                 ,
    #endif
        queuePushHead                           ,

    -- ** pushNth #method:pushNth#

    #if ENABLE_OVERLOADING
        QueuePushNthMethodInfo                  ,
    #endif
        queuePushNth                            ,

    -- ** pushTail #method:pushTail#

    #if ENABLE_OVERLOADING
        QueuePushTailMethodInfo                 ,
    #endif
        queuePushTail                           ,

    -- ** remove #method:remove#

    #if ENABLE_OVERLOADING
        QueueRemoveMethodInfo                   ,
    #endif
        queueRemove                             ,

    -- ** removeAll #method:removeAll#

    #if ENABLE_OVERLOADING
        QueueRemoveAllMethodInfo                ,
    #endif
        queueRemoveAll                          ,

    -- ** reverse #method:reverse#

    #if ENABLE_OVERLOADING
        QueueReverseMethodInfo                  ,
    #endif
        queueReverse                            ,

     -- * Properties
    -- ** head #attr:head#
    {- | a pointer to the first element of the queue
    -}
        clearQueueHead                          ,
        getQueueHead                            ,
    #if ENABLE_OVERLOADING
        queue_head                              ,
    #endif
        setQueueHead                            ,

    -- ** length #attr:length#
    {- | the number of elements in the queue
    -}
        getQueueLength                          ,
    #if ENABLE_OVERLOADING
        queue_length                            ,
    #endif
        setQueueLength                          ,

    -- ** tail #attr:tail#
    {- | a pointer to the last element of the queue
    -}
        clearQueueTail                          ,
        getQueueTail                            ,
    #if 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.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Callbacks as GLib.Callbacks

    -- | Memory-managed wrapper type.
    newtype Queue = Queue (ManagedPtr Queue)
    instance WrappedPtr Queue where
        wrappedPtrCalloc = callocBytes 24
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr Queue)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `Queue` struct initialized to zero.
    newZeroQueue :: MonadIO m => m Queue
    newZeroQueue = liftIO $ wrappedPtrCalloc >>= wrapPtr Queue

    instance tag ~ 'AttrSet => Constructible Queue tag where
        new _ attrs = do
            o <- newZeroQueue
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `Queue`.
    noQueue :: Maybe Queue
    noQueue = Nothing

    {- |
    Get the value of the “@head@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' queue #head
    @
    -}
    getQueueHead :: MonadIO m => Queue -> m ([Ptr ()])
    getQueueHead s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO (Ptr (GList (Ptr ())))
        val' <- unpackGList val
        return val'

    {- |
    Set the value of the “@head@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' queue [ #head 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setQueueHead :: MonadIO m => Queue -> Ptr (GList (Ptr ())) -> m ()
    setQueueHead s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (val :: Ptr (GList (Ptr ())))

    {- |
    Set the value of the “@head@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #head
    @
    -}
    clearQueueHead :: MonadIO m => Queue -> m ()
    clearQueueHead s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr (GList (Ptr ())))

    #if ENABLE_OVERLOADING
    data QueueHeadFieldInfo
    instance AttrInfo QueueHeadFieldInfo where
        type AttrAllowedOps QueueHeadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint QueueHeadFieldInfo = (~) (Ptr (GList (Ptr ())))
        type AttrBaseTypeConstraint QueueHeadFieldInfo = (~) Queue
        type AttrGetType QueueHeadFieldInfo = [Ptr ()]
        type AttrLabel QueueHeadFieldInfo = "head"
        type AttrOrigin QueueHeadFieldInfo = Queue
        attrGet _ = getQueueHead
        attrSet _ = setQueueHead
        attrConstruct = undefined
        attrClear _ = clearQueueHead

    queue_head :: AttrLabelProxy "head"
    queue_head = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@tail@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' queue #tail
    @
    -}
    getQueueTail :: MonadIO m => Queue -> m ([Ptr ()])
    getQueueTail s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO (Ptr (GList (Ptr ())))
        val' <- unpackGList val
        return val'

    {- |
    Set the value of the “@tail@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' queue [ #tail 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setQueueTail :: MonadIO m => Queue -> Ptr (GList (Ptr ())) -> m ()
    setQueueTail s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: Ptr (GList (Ptr ())))

    {- |
    Set the value of the “@tail@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #tail
    @
    -}
    clearQueueTail :: MonadIO m => Queue -> m ()
    clearQueueTail s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr (GList (Ptr ())))

    #if ENABLE_OVERLOADING
    data QueueTailFieldInfo
    instance AttrInfo QueueTailFieldInfo where
        type AttrAllowedOps QueueTailFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint QueueTailFieldInfo = (~) (Ptr (GList (Ptr ())))
        type AttrBaseTypeConstraint QueueTailFieldInfo = (~) Queue
        type AttrGetType QueueTailFieldInfo = [Ptr ()]
        type AttrLabel QueueTailFieldInfo = "tail"
        type AttrOrigin QueueTailFieldInfo = Queue
        attrGet _ = getQueueTail
        attrSet _ = setQueueTail
        attrConstruct = undefined
        attrClear _ = clearQueueTail

    queue_tail :: AttrLabelProxy "tail"
    queue_tail = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@length@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' queue #length
    @
    -}
    getQueueLength :: MonadIO m => Queue -> m Word32
    getQueueLength s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO Word32
        return val

    {- |
    Set the value of the “@length@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' queue [ #length 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setQueueLength :: MonadIO m => Queue -> Word32 -> m ()
    setQueueLength s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: Word32)

    #if ENABLE_OVERLOADING
    data QueueLengthFieldInfo
    instance AttrInfo QueueLengthFieldInfo where
        type AttrAllowedOps QueueLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint QueueLengthFieldInfo = (~) Word32
        type AttrBaseTypeConstraint QueueLengthFieldInfo = (~) Queue
        type AttrGetType QueueLengthFieldInfo = Word32
        type AttrLabel QueueLengthFieldInfo = "length"
        type AttrOrigin QueueLengthFieldInfo = Queue
        attrGet _ = getQueueLength
        attrSet _ = setQueueLength
        attrConstruct = undefined
        attrClear _ = undefined

    queue_length :: AttrLabelProxy "length"
    queue_length = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Queue
    type instance O.AttributeList Queue = QueueAttributeList
    type QueueAttributeList = ('[ '("head", QueueHeadFieldInfo), '("tail", QueueTailFieldInfo), '("length", QueueLengthFieldInfo)] :: [(Symbol, *)])
    #endif

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

    foreign import ccall "g_queue_clear" g_queue_clear ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO ()

    {- |
    Removes all the elements in /@queue@/. If queue elements contain
    dynamically-allocated memory, they should be freed first.

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

    #if ENABLE_OVERLOADING
    data QueueClearMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QueueClearMethodInfo Queue signature where
        overloadedMethod _ = queueClear

    #endif

    -- method Queue::clear_full
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function to be called to free memory allocated", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_clear_full" g_queue_clear_full ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO ()

    {- |
    Convenience method, which frees all the memory used by a 'GI.GLib.Structs.Queue.Queue',
    and calls the provided /@freeFunc@/ on each item in the 'GI.GLib.Structs.Queue.Queue'.

    /Since: 2.60/
    -}
    queueClearFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a pointer to a 'GI.GLib.Structs.Queue.Queue' -}
        -> Maybe (GLib.Callbacks.DestroyNotify)
        {- ^ /@freeFunc@/: the function to be called to free memory allocated -}
        -> m ()
    queueClearFull queue freeFunc = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        maybeFreeFunc <- case freeFunc of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jFreeFunc -> do
                ptrfreeFunc <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
                jFreeFunc' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrfreeFunc) jFreeFunc)
                poke ptrfreeFunc jFreeFunc'
                return jFreeFunc'
        g_queue_clear_full queue' maybeFreeFunc
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueueClearFullMethodInfo
    instance (signature ~ (Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m) => O.MethodInfo QueueClearFullMethodInfo Queue signature where
        overloadedMethod _ = queueClearFull

    #endif

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

    foreign import ccall "g_queue_free" g_queue_free ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO ()

    {- |
    Frees the memory allocated for the 'GI.GLib.Structs.Queue.Queue'. Only call this function
    if /@queue@/ was created with @/g_queue_new()/@. If queue elements contain
    dynamically-allocated memory, they should be freed first.

    If queue elements contain dynamically-allocated memory, you should
    either use 'GI.GLib.Structs.Queue.queueFreeFull' or free them manually first.
    -}
    queueFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m ()
    queueFree queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_free queue'
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueueFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QueueFreeMethodInfo Queue signature where
        overloadedMethod _ = queueFree

    #endif

    -- method Queue::free_full
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the function to be called to free each element's data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_free_full" g_queue_free_full ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO ()

    {- |
    Convenience method, which frees all the memory used by a 'GI.GLib.Structs.Queue.Queue',
    and calls the specified destroy function on every element\'s data.

    /@freeFunc@/ should not modify the queue (eg, by removing the freed
    element from it).

    /Since: 2.32/
    -}
    queueFreeFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a pointer to a 'GI.GLib.Structs.Queue.Queue' -}
        -> GLib.Callbacks.DestroyNotify
        {- ^ /@freeFunc@/: the function to be called to free each element\'s data -}
        -> m ()
    queueFreeFull queue freeFunc = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        ptrfreeFunc <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
        freeFunc' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrfreeFunc) freeFunc)
        poke ptrfreeFunc freeFunc'
        g_queue_free_full queue' freeFunc'
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueueFreeFullMethodInfo
    instance (signature ~ (GLib.Callbacks.DestroyNotify -> m ()), MonadIO m) => O.MethodInfo QueueFreeFullMethodInfo Queue signature where
        overloadedMethod _ = queueFreeFull

    #endif

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

    foreign import ccall "g_queue_get_length" g_queue_get_length ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO Word32

    {- |
    Returns the number of items in /@queue@/.

    /Since: 2.4/
    -}
    queueGetLength ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m Word32
        {- ^ __Returns:__ the number of items in /@queue@/ -}
    queueGetLength queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_get_length queue'
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueueGetLengthMethodInfo
    instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueueGetLengthMethodInfo Queue signature where
        overloadedMethod _ = queueGetLength

    #endif

    -- method Queue::index
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_index" g_queue_index ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO Int32

    {- |
    Returns the position of the first element in /@queue@/ which contains /@data@/.

    /Since: 2.4/
    -}
    queueIndex ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Ptr ()
        {- ^ /@data@/: the data to find -}
        -> m Int32
        {- ^ __Returns:__ the position of the first element in /@queue@/ which
        contains /@data@/, or -1 if no element in /@queue@/ contains /@data@/ -}
    queueIndex queue data_ = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_index queue' data_
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueueIndexMethodInfo
    instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.MethodInfo QueueIndexMethodInfo Queue signature where
        overloadedMethod _ = queueIndex

    #endif

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

    foreign import ccall "g_queue_init" g_queue_init ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO ()

    {- |
    A statically-allocated 'GI.GLib.Structs.Queue.Queue' must be initialized with this function
    before it can be used. Alternatively you can initialize it with
    @/G_QUEUE_INIT/@. It is not necessary to initialize queues created with
    @/g_queue_new()/@.

    /Since: 2.14/
    -}
    queueInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: an uninitialized 'GI.GLib.Structs.Queue.Queue' -}
        -> m ()
    queueInit queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_init queue'
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueueInitMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QueueInitMethodInfo Queue signature where
        overloadedMethod _ = queueInit

    #endif

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

    foreign import ccall "g_queue_is_empty" g_queue_is_empty ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO CInt

    {- |
    Returns 'True' if the queue is empty.
    -}
    queueIsEmpty ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the queue is empty -}
    queueIsEmpty queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_is_empty queue'
        let result' = (/= 0) result
        touchManagedPtr queue
        return result'

    #if ENABLE_OVERLOADING
    data QueueIsEmptyMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo QueueIsEmptyMethodInfo Queue signature where
        overloadedMethod _ = queueIsEmpty

    #endif

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

    foreign import ccall "g_queue_peek_head" g_queue_peek_head ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO (Ptr ())

    {- |
    Returns the first element of the queue.
    -}
    queuePeekHead ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data of the first element in the queue, or 'Nothing'
        if the queue is empty -}
    queuePeekHead queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_peek_head queue'
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePeekHeadMethodInfo
    instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo QueuePeekHeadMethodInfo Queue signature where
        overloadedMethod _ = queuePeekHead

    #endif

    -- method Queue::peek_nth
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position of the element", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_peek_nth" g_queue_peek_nth ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Word32 ->                               -- n : TBasicType TUInt
        IO (Ptr ())

    {- |
    Returns the /@n@/\'th element of /@queue@/.

    /Since: 2.4/
    -}
    queuePeekNth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Word32
        {- ^ /@n@/: the position of the element -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data for the /@n@/\'th element of /@queue@/,
        or 'Nothing' if /@n@/ is off the end of /@queue@/ -}
    queuePeekNth queue n = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_peek_nth queue' n
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePeekNthMethodInfo
    instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo QueuePeekNthMethodInfo Queue signature where
        overloadedMethod _ = queuePeekNth

    #endif

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

    foreign import ccall "g_queue_peek_tail" g_queue_peek_tail ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO (Ptr ())

    {- |
    Returns the last element of the queue.
    -}
    queuePeekTail ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data of the last element in the queue, or 'Nothing'
        if the queue is empty -}
    queuePeekTail queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_peek_tail queue'
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePeekTailMethodInfo
    instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo QueuePeekTailMethodInfo Queue signature where
        overloadedMethod _ = queuePeekTail

    #endif

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

    foreign import ccall "g_queue_pop_head" g_queue_pop_head ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO (Ptr ())

    {- |
    Removes the first element of the queue and returns its data.
    -}
    queuePopHead ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data of the first element in the queue, or 'Nothing'
        if the queue is empty -}
    queuePopHead queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_pop_head queue'
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePopHeadMethodInfo
    instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo QueuePopHeadMethodInfo Queue signature where
        overloadedMethod _ = queuePopHead

    #endif

    -- method Queue::pop_nth
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position of the element", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_pop_nth" g_queue_pop_nth ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Word32 ->                               -- n : TBasicType TUInt
        IO (Ptr ())

    {- |
    Removes the /@n@/\'th element of /@queue@/ and returns its data.

    /Since: 2.4/
    -}
    queuePopNth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Word32
        {- ^ /@n@/: the position of the element -}
        -> m (Ptr ())
        {- ^ __Returns:__ the element\'s data, or 'Nothing' if /@n@/ is off the end of /@queue@/ -}
    queuePopNth queue n = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_pop_nth queue' n
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePopNthMethodInfo
    instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo QueuePopNthMethodInfo Queue signature where
        overloadedMethod _ = queuePopNth

    #endif

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

    foreign import ccall "g_queue_pop_tail" g_queue_pop_tail ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO (Ptr ())

    {- |
    Removes the last element of the queue and returns its data.
    -}
    queuePopTail ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m (Ptr ())
        {- ^ __Returns:__ the data of the last element in the queue, or 'Nothing'
        if the queue is empty -}
    queuePopTail queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_pop_tail queue'
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueuePopTailMethodInfo
    instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo QueuePopTailMethodInfo Queue signature where
        overloadedMethod _ = queuePopTail

    #endif

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

    foreign import ccall "g_queue_push_head" g_queue_push_head ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO ()

    {- |
    Adds a new element at the head of the queue.
    -}
    queuePushHead ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue'. -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new element. -}
        -> m ()
    queuePushHead queue data_ = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_push_head queue' data_
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueuePushHeadMethodInfo
    instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.MethodInfo QueuePushHeadMethodInfo Queue signature where
        overloadedMethod _ = queuePushHead

    #endif

    -- method Queue::push_nth
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data for the new element", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to insert the new element. If @n is negative or\n    larger than the number of elements in the @queue, the element is\n    added to the end of the queue.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_push_nth" g_queue_push_nth ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        Int32 ->                                -- n : TBasicType TInt
        IO ()

    {- |
    Inserts a new element into /@queue@/ at the given position.

    /Since: 2.4/
    -}
    queuePushNth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new element -}
        -> Int32
        {- ^ /@n@/: the position to insert the new element. If /@n@/ is negative or
        larger than the number of elements in the /@queue@/, the element is
        added to the end of the queue. -}
        -> m ()
    queuePushNth queue data_ n = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_push_nth queue' data_ n
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueuePushNthMethodInfo
    instance (signature ~ (Ptr () -> Int32 -> m ()), MonadIO m) => O.MethodInfo QueuePushNthMethodInfo Queue signature where
        overloadedMethod _ = queuePushNth

    #endif

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

    foreign import ccall "g_queue_push_tail" g_queue_push_tail ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO ()

    {- |
    Adds a new element at the tail of the queue.
    -}
    queuePushTail ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Ptr ()
        {- ^ /@data@/: the data for the new element -}
        -> m ()
    queuePushTail queue data_ = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_push_tail queue' data_
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueuePushTailMethodInfo
    instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.MethodInfo QueuePushTailMethodInfo Queue signature where
        overloadedMethod _ = queuePushTail

    #endif

    -- method Queue::remove
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_remove" g_queue_remove ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO CInt

    {- |
    Removes the first element in /@queue@/ that contains /@data@/.

    /Since: 2.4/
    -}
    queueRemove ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Ptr ()
        {- ^ /@data@/: the data to remove -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@data@/ was found and removed from /@queue@/ -}
    queueRemove queue data_ = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_remove queue' data_
        let result' = (/= 0) result
        touchManagedPtr queue
        return result'

    #if ENABLE_OVERLOADING
    data QueueRemoveMethodInfo
    instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.MethodInfo QueueRemoveMethodInfo Queue signature where
        overloadedMethod _ = queueRemove

    #endif

    -- method Queue::remove_all
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "queue", argType = TInterface (Name {namespace = "GLib", name = "Queue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQueue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_queue_remove_all" g_queue_remove_all ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        Ptr () ->                               -- data : TBasicType TPtr
        IO Word32

    {- |
    Remove all elements whose data equals /@data@/ from /@queue@/.

    /Since: 2.4/
    -}
    queueRemoveAll ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> Ptr ()
        {- ^ /@data@/: the data to remove -}
        -> m Word32
        {- ^ __Returns:__ the number of elements removed from /@queue@/ -}
    queueRemoveAll queue data_ = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        result <- g_queue_remove_all queue' data_
        touchManagedPtr queue
        return result

    #if ENABLE_OVERLOADING
    data QueueRemoveAllMethodInfo
    instance (signature ~ (Ptr () -> m Word32), MonadIO m) => O.MethodInfo QueueRemoveAllMethodInfo Queue signature where
        overloadedMethod _ = queueRemoveAll

    #endif

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

    foreign import ccall "g_queue_reverse" g_queue_reverse ::
        Ptr Queue ->                            -- queue : TInterface (Name {namespace = "GLib", name = "Queue"})
        IO ()

    {- |
    Reverses the order of the items in /@queue@/.

    /Since: 2.4/
    -}
    queueReverse ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Queue
        {- ^ /@queue@/: a 'GI.GLib.Structs.Queue.Queue' -}
        -> m ()
    queueReverse queue = liftIO $ do
        queue' <- unsafeManagedPtrGetPtr queue
        g_queue_reverse queue'
        touchManagedPtr queue
        return ()

    #if ENABLE_OVERLOADING
    data QueueReverseMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QueueReverseMethodInfo Queue signature where
        overloadedMethod _ = queueReverse

    #endif

    #if 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.MethodInfo info Queue p) => O.IsLabelProxy t (Queue -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

    #endif