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

A 'GI.GObject.Structs.ValueArray.ValueArray' contains an array of 'GI.GObject.Structs.Value.Value' elements.
-}

module GI.GObject.Structs.ValueArray
    ( 

-- * Exported types
    ValueArray(..)                          ,
    newZeroValueArray                       ,
    noValueArray                            ,


 -- * Methods
-- ** append #method:append#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayAppendMethodInfo              ,
#endif
    valueArrayAppend                        ,


-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayCopyMethodInfo                ,
#endif
    valueArrayCopy                          ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayFreeMethodInfo                ,
#endif
    valueArrayFree                          ,


-- ** getNth #method:getNth#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayGetNthMethodInfo              ,
#endif
    valueArrayGetNth                        ,


-- ** insert #method:insert#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayInsertMethodInfo              ,
#endif
    valueArrayInsert                        ,


-- ** new #method:new#
    valueArrayNew                           ,


-- ** prepend #method:prepend#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayPrependMethodInfo             ,
#endif
    valueArrayPrepend                       ,


-- ** remove #method:remove#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArrayRemoveMethodInfo              ,
#endif
    valueArrayRemove                        ,


-- ** sort #method:sort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ValueArraySortMethodInfo                ,
#endif
    valueArraySort                          ,




 -- * Properties
-- ** nValues #attr:nValues#
    getValueArrayNValues                    ,
    setValueArrayNValues                    ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    valueArray_nValues                      ,
#endif


-- ** values #attr:values#
    clearValueArrayValues                   ,
    getValueArrayValues                     ,
    setValueArrayValues                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    valueArray_values                       ,
#endif




    ) 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.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

newtype ValueArray = ValueArray (ManagedPtr ValueArray)
foreign import ccall "g_value_array_get_type" c_g_value_array_get_type :: 
    IO GType

instance BoxedObject ValueArray where
    boxedType _ = c_g_value_array_get_type

-- | Construct a `ValueArray` struct initialized to zero.
newZeroValueArray :: MonadIO m => m ValueArray
newZeroValueArray = liftIO $ callocBoxedBytes 24 >>= wrapBoxed ValueArray

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


noValueArray :: Maybe ValueArray
noValueArray = Nothing

getValueArrayNValues :: MonadIO m => ValueArray -> m Word32
getValueArrayNValues s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setValueArrayNValues :: MonadIO m => ValueArray -> Word32 -> m ()
setValueArrayNValues s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayNValuesFieldInfo
instance AttrInfo ValueArrayNValuesFieldInfo where
    type AttrAllowedOps ValueArrayNValuesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ValueArrayNValuesFieldInfo = (~) Word32
    type AttrBaseTypeConstraint ValueArrayNValuesFieldInfo = (~) ValueArray
    type AttrGetType ValueArrayNValuesFieldInfo = Word32
    type AttrLabel ValueArrayNValuesFieldInfo = "n_values"
    type AttrOrigin ValueArrayNValuesFieldInfo = ValueArray
    attrGet _ = getValueArrayNValues
    attrSet _ = setValueArrayNValues
    attrConstruct = undefined
    attrClear _ = undefined

valueArray_nValues :: AttrLabelProxy "nValues"
valueArray_nValues = AttrLabelProxy

#endif


getValueArrayValues :: MonadIO m => ValueArray -> m (Maybe GValue)
getValueArrayValues s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr GValue)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed GValue) val'
        return val''
    return result

setValueArrayValues :: MonadIO m => ValueArray -> Ptr GValue -> m ()
setValueArrayValues s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr GValue)

clearValueArrayValues :: MonadIO m => ValueArray -> m ()
clearValueArrayValues s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr GValue)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayValuesFieldInfo
instance AttrInfo ValueArrayValuesFieldInfo where
    type AttrAllowedOps ValueArrayValuesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ValueArrayValuesFieldInfo = (~) (Ptr GValue)
    type AttrBaseTypeConstraint ValueArrayValuesFieldInfo = (~) ValueArray
    type AttrGetType ValueArrayValuesFieldInfo = Maybe GValue
    type AttrLabel ValueArrayValuesFieldInfo = "values"
    type AttrOrigin ValueArrayValuesFieldInfo = ValueArray
    attrGet _ = getValueArrayValues
    attrSet _ = setValueArrayValues
    attrConstruct = undefined
    attrClear _ = clearValueArrayValues

valueArray_values :: AttrLabelProxy "values"
valueArray_values = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList ValueArray
type instance O.AttributeList ValueArray = ValueArrayAttributeList
type ValueArrayAttributeList = ('[ '("nValues", ValueArrayNValuesFieldInfo), '("values", ValueArrayValuesFieldInfo)] :: [(Symbol, *)])
#endif

-- method ValueArray::new
-- method type : Constructor
-- Args : [Arg {argCName = "n_prealloced", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of values to preallocate space for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_new" g_value_array_new :: 
    Word32 ->                               -- n_prealloced : TBasicType TUInt
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayNew ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_sized_new()/@ instead."] #-}
{- |
Allocate and initialize a new 'GI.GObject.Structs.ValueArray.ValueArray', optionally preserve space
for /@nPrealloced@/ elements. New arrays always contain 0 elements,
regardless of the value of /@nPrealloced@/.
-}
valueArrayNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    {- ^ /@nPrealloced@/: number of values to preallocate space for -}
    -> m ValueArray
    {- ^ __Returns:__ a newly allocated 'GI.GObject.Structs.ValueArray.ValueArray' with 0 values -}
valueArrayNew nPrealloced = liftIO $ do
    result <- g_value_array_new nPrealloced
    checkUnexpectedReturnNULL "valueArrayNew" result
    result' <- (wrapBoxed ValueArray) result
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method ValueArray::append
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to add an element to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GValue to copy into #GValueArray, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_append" g_value_array_append :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayAppend ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_append_val()/@ instead."] #-}
{- |
Insert a copy of /@value@/ as last element of /@valueArray@/. If /@value@/ is
'Nothing', an uninitialized value is appended.
-}
valueArrayAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to add an element to -}
    -> Maybe (GValue)
    {- ^ /@value@/: 'GI.GObject.Structs.Value.Value' to copy into 'GI.GObject.Structs.ValueArray.ValueArray', or 'Nothing' -}
    -> m ValueArray
    {- ^ __Returns:__ the 'GI.GObject.Structs.ValueArray.ValueArray' passed in as /@valueArray@/ -}
valueArrayAppend valueArray value = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    maybeValue <- case value of
        Nothing -> return nullPtr
        Just jValue -> do
            jValue' <- unsafeManagedPtrGetPtr jValue
            return jValue'
    result <- g_value_array_append valueArray' maybeValue
    checkUnexpectedReturnNULL "valueArrayAppend" result
    result' <- (newBoxed ValueArray) result
    touchManagedPtr valueArray
    whenJust value touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayAppendMethodInfo
instance (signature ~ (Maybe (GValue) -> m ValueArray), MonadIO m) => O.MethodInfo ValueArrayAppendMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayAppend

#endif

-- method ValueArray::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_copy" g_value_array_copy :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayCopy ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_ref()/@ instead."] #-}
{- |
Construct an exact copy of a 'GI.GObject.Structs.ValueArray.ValueArray' by duplicating all its
contents.
-}
valueArrayCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to copy -}
    -> m ValueArray
    {- ^ __Returns:__ Newly allocated copy of 'GI.GObject.Structs.ValueArray.ValueArray' -}
valueArrayCopy valueArray = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    result <- g_value_array_copy valueArray'
    checkUnexpectedReturnNULL "valueArrayCopy" result
    result' <- (wrapBoxed ValueArray) result
    touchManagedPtr valueArray
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayCopyMethodInfo
instance (signature ~ (m ValueArray), MonadIO m) => O.MethodInfo ValueArrayCopyMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayCopy

#endif

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

foreign import ccall "g_value_array_free" g_value_array_free :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    IO ()

{-# DEPRECATED valueArrayFree ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_unref()/@ instead."] #-}
{- |
Free a 'GI.GObject.Structs.ValueArray.ValueArray' including its contents.
-}
valueArrayFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to free -}
    -> m ()
valueArrayFree valueArray = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    g_value_array_free valueArray'
    touchManagedPtr valueArray
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ValueArrayFreeMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayFree

#endif

-- method ValueArray::get_nth
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to get a value from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of the value of interest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_get_nth" g_value_array_get_nth :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    Word32 ->                               -- index_ : TBasicType TUInt
    IO (Ptr GValue)

{-# DEPRECATED valueArrayGetNth ["(Since version 2.32)","Use @/g_array_index()/@ instead."] #-}
{- |
Return a pointer to the value at /@index_@/ containd in /@valueArray@/.
-}
valueArrayGetNth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to get a value from -}
    -> Word32
    {- ^ /@index_@/: index of the value of interest -}
    -> m GValue
    {- ^ __Returns:__ pointer to a value at /@index_@/ in /@valueArray@/ -}
valueArrayGetNth valueArray index_ = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    result <- g_value_array_get_nth valueArray' index_
    checkUnexpectedReturnNULL "valueArrayGetNth" result
    result' <- (newBoxed GValue) result
    touchManagedPtr valueArray
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayGetNthMethodInfo
instance (signature ~ (Word32 -> m GValue), MonadIO m) => O.MethodInfo ValueArrayGetNthMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayGetNth

#endif

-- method ValueArray::insert
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to add an element to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "insertion position, must be <= value_array->;n_values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GValue to copy into #GValueArray, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_insert" g_value_array_insert :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayInsert ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_insert_val()/@ instead."] #-}
{- |
Insert a copy of /@value@/ at specified position into /@valueArray@/. If /@value@/
is 'Nothing', an uninitialized value is inserted.
-}
valueArrayInsert ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to add an element to -}
    -> Word32
    {- ^ /@index_@/: insertion position, must be \<= value_array->;n_values -}
    -> Maybe (GValue)
    {- ^ /@value@/: 'GI.GObject.Structs.Value.Value' to copy into 'GI.GObject.Structs.ValueArray.ValueArray', or 'Nothing' -}
    -> m ValueArray
    {- ^ __Returns:__ the 'GI.GObject.Structs.ValueArray.ValueArray' passed in as /@valueArray@/ -}
valueArrayInsert valueArray index_ value = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    maybeValue <- case value of
        Nothing -> return nullPtr
        Just jValue -> do
            jValue' <- unsafeManagedPtrGetPtr jValue
            return jValue'
    result <- g_value_array_insert valueArray' index_ maybeValue
    checkUnexpectedReturnNULL "valueArrayInsert" result
    result' <- (newBoxed ValueArray) result
    touchManagedPtr valueArray
    whenJust value touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayInsertMethodInfo
instance (signature ~ (Word32 -> Maybe (GValue) -> m ValueArray), MonadIO m) => O.MethodInfo ValueArrayInsertMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayInsert

#endif

-- method ValueArray::prepend
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to add an element to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GValue to copy into #GValueArray, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_prepend" g_value_array_prepend :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayPrepend ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_prepend_val()/@ instead."] #-}
{- |
Insert a copy of /@value@/ as first element of /@valueArray@/. If /@value@/ is
'Nothing', an uninitialized value is prepended.
-}
valueArrayPrepend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to add an element to -}
    -> Maybe (GValue)
    {- ^ /@value@/: 'GI.GObject.Structs.Value.Value' to copy into 'GI.GObject.Structs.ValueArray.ValueArray', or 'Nothing' -}
    -> m ValueArray
    {- ^ __Returns:__ the 'GI.GObject.Structs.ValueArray.ValueArray' passed in as /@valueArray@/ -}
valueArrayPrepend valueArray value = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    maybeValue <- case value of
        Nothing -> return nullPtr
        Just jValue -> do
            jValue' <- unsafeManagedPtrGetPtr jValue
            return jValue'
    result <- g_value_array_prepend valueArray' maybeValue
    checkUnexpectedReturnNULL "valueArrayPrepend" result
    result' <- (newBoxed ValueArray) result
    touchManagedPtr valueArray
    whenJust value touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayPrependMethodInfo
instance (signature ~ (Maybe (GValue) -> m ValueArray), MonadIO m) => O.MethodInfo ValueArrayPrependMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayPrepend

#endif

-- method ValueArray::remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to remove an element from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position of value to remove, which must be less than\n    @value_array->n_values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_remove" g_value_array_remove :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    Word32 ->                               -- index_ : TBasicType TUInt
    IO (Ptr ValueArray)

{-# DEPRECATED valueArrayRemove ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_remove_index()/@ instead."] #-}
{- |
Remove the value at position /@index_@/ from /@valueArray@/.
-}
valueArrayRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to remove an element from -}
    -> Word32
    {- ^ /@index_@/: position of value to remove, which must be less than
    /@valueArray@/->n_values -}
    -> m ValueArray
    {- ^ __Returns:__ the 'GI.GObject.Structs.ValueArray.ValueArray' passed in as /@valueArray@/ -}
valueArrayRemove valueArray index_ = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    result <- g_value_array_remove valueArray' index_
    checkUnexpectedReturnNULL "valueArrayRemove" result
    result' <- (newBoxed ValueArray) result
    touchManagedPtr valueArray
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArrayRemoveMethodInfo
instance (signature ~ (Word32 -> m ValueArray), MonadIO m) => O.MethodInfo ValueArrayRemoveMethodInfo ValueArray signature where
    overloadedMethod _ = valueArrayRemove

#endif

-- method ValueArray::sort
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "value_array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GValueArray to sort", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compare_func", argType = TInterface (Name {namespace = "GLib", name = "CompareDataFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to compare elements", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "extra data argument provided for @compare_func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ValueArray"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_value_array_sort_with_data" g_value_array_sort_with_data :: 
    Ptr ValueArray ->                       -- value_array : TInterface (Name {namespace = "GObject", name = "ValueArray"})
    FunPtr GLib.Callbacks.C_CompareDataFunc -> -- compare_func : TInterface (Name {namespace = "GLib", name = "CompareDataFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO (Ptr ValueArray)

{-# DEPRECATED valueArraySort ["(Since version 2.32)","Use 'GI.GLib.Structs.Array.Array' and @/g_array_sort_with_data()/@."] #-}
{- |
Sort /@valueArray@/ using /@compareFunc@/ to compare the elements according
to the semantics of 'GI.GLib.Callbacks.CompareDataFunc'.

The current implementation uses the same sorting algorithm as standard
C @/qsort()/@ function.
-}
valueArraySort ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ValueArray
    {- ^ /@valueArray@/: 'GI.GObject.Structs.ValueArray.ValueArray' to sort -}
    -> GLib.Callbacks.CompareDataFunc
    {- ^ /@compareFunc@/: function to compare elements -}
    -> m ValueArray
    {- ^ __Returns:__ the 'GI.GObject.Structs.ValueArray.ValueArray' passed in as /@valueArray@/ -}
valueArraySort valueArray compareFunc = liftIO $ do
    valueArray' <- unsafeManagedPtrGetPtr valueArray
    compareFunc' <- GLib.Callbacks.mk_CompareDataFunc (GLib.Callbacks.wrap_CompareDataFunc Nothing (GLib.Callbacks.drop_closures_CompareDataFunc compareFunc))
    let userData = nullPtr
    result <- g_value_array_sort_with_data valueArray' compareFunc' userData
    checkUnexpectedReturnNULL "valueArraySort" result
    result' <- (newBoxed ValueArray) result
    safeFreeFunPtr $ castFunPtrToPtr compareFunc'
    touchManagedPtr valueArray
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ValueArraySortMethodInfo
instance (signature ~ (GLib.Callbacks.CompareDataFunc -> m ValueArray), MonadIO m) => O.MethodInfo ValueArraySortMethodInfo ValueArray signature where
    overloadedMethod _ = valueArraySort

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveValueArrayMethod (t :: Symbol) (o :: *) :: * where
    ResolveValueArrayMethod "append" o = ValueArrayAppendMethodInfo
    ResolveValueArrayMethod "copy" o = ValueArrayCopyMethodInfo
    ResolveValueArrayMethod "free" o = ValueArrayFreeMethodInfo
    ResolveValueArrayMethod "insert" o = ValueArrayInsertMethodInfo
    ResolveValueArrayMethod "prepend" o = ValueArrayPrependMethodInfo
    ResolveValueArrayMethod "remove" o = ValueArrayRemoveMethodInfo
    ResolveValueArrayMethod "sort" o = ValueArraySortMethodInfo
    ResolveValueArrayMethod "getNth" o = ValueArrayGetNthMethodInfo
    ResolveValueArrayMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveValueArrayMethod t ValueArray, O.MethodInfo info ValueArray p) => O.IsLabelProxy t (ValueArray -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveValueArrayMethod t ValueArray, O.MethodInfo info ValueArray p) => O.IsLabel t (ValueArray -> 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