{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- This object provides an abstraction for creating threads. The default
-- implementation uses a regular GThreadPool to start tasks.
-- 
-- Subclasses can be made to create custom threads.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gst.Objects.TaskPool
    ( 

-- * Exported types
    TaskPool(..)                            ,
    IsTaskPool                              ,
    toTaskPool                              ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveTaskPoolMethod                   ,
#endif


-- ** cleanup #method:cleanup#

#if defined(ENABLE_OVERLOADING)
    TaskPoolCleanupMethodInfo               ,
#endif
    taskPoolCleanup                         ,


-- ** join #method:join#

#if defined(ENABLE_OVERLOADING)
    TaskPoolJoinMethodInfo                  ,
#endif
    taskPoolJoin                            ,


-- ** new #method:new#

    taskPoolNew                             ,


-- ** prepare #method:prepare#

#if defined(ENABLE_OVERLOADING)
    TaskPoolPrepareMethodInfo               ,
#endif
    taskPoolPrepare                         ,


-- ** push #method:push#

#if defined(ENABLE_OVERLOADING)
    TaskPoolPushMethodInfo                  ,
#endif
    taskPoolPush                            ,




    ) 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.GClosure as B.GClosure
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.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.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object

-- | Memory-managed wrapper type.
newtype TaskPool = TaskPool (SP.ManagedPtr TaskPool)
    deriving (TaskPool -> TaskPool -> Bool
(TaskPool -> TaskPool -> Bool)
-> (TaskPool -> TaskPool -> Bool) -> Eq TaskPool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaskPool -> TaskPool -> Bool
$c/= :: TaskPool -> TaskPool -> Bool
== :: TaskPool -> TaskPool -> Bool
$c== :: TaskPool -> TaskPool -> Bool
Eq)

instance SP.ManagedPtrNewtype TaskPool where
    toManagedPtr :: TaskPool -> ManagedPtr TaskPool
toManagedPtr (TaskPool ManagedPtr TaskPool
p) = ManagedPtr TaskPool
p

foreign import ccall "gst_task_pool_get_type"
    c_gst_task_pool_get_type :: IO B.Types.GType

instance B.Types.TypedObject TaskPool where
    glibType :: IO GType
glibType = IO GType
c_gst_task_pool_get_type

instance B.Types.GObject TaskPool

-- | Convert 'TaskPool' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TaskPool where
    toGValue :: TaskPool -> IO GValue
toGValue TaskPool
o = do
        GType
gtype <- IO GType
c_gst_task_pool_get_type
        TaskPool -> (Ptr TaskPool -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TaskPool
o (GType
-> (GValue -> Ptr TaskPool -> IO ()) -> Ptr TaskPool -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TaskPool -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO TaskPool
fromGValue GValue
gv = do
        Ptr TaskPool
ptr <- GValue -> IO (Ptr TaskPool)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr TaskPool)
        (ManagedPtr TaskPool -> TaskPool) -> Ptr TaskPool -> IO TaskPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TaskPool -> TaskPool
TaskPool Ptr TaskPool
ptr
        
    

-- | Type class for types which can be safely cast to `TaskPool`, for instance with `toTaskPool`.
class (SP.GObject o, O.IsDescendantOf TaskPool o) => IsTaskPool o
instance (SP.GObject o, O.IsDescendantOf TaskPool o) => IsTaskPool o

instance O.HasParentTypes TaskPool
type instance O.ParentTypes TaskPool = '[Gst.Object.Object, GObject.Object.Object]

-- | Cast to `TaskPool`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTaskPool :: (MonadIO m, IsTaskPool o) => o -> m TaskPool
toTaskPool :: o -> m TaskPool
toTaskPool = IO TaskPool -> m TaskPool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskPool -> m TaskPool)
-> (o -> IO TaskPool) -> o -> m TaskPool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TaskPool -> TaskPool) -> o -> IO TaskPool
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr TaskPool -> TaskPool
TaskPool

#if defined(ENABLE_OVERLOADING)
type family ResolveTaskPoolMethod (t :: Symbol) (o :: *) :: * where
    ResolveTaskPoolMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveTaskPoolMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTaskPoolMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTaskPoolMethod "cleanup" o = TaskPoolCleanupMethodInfo
    ResolveTaskPoolMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveTaskPoolMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTaskPoolMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTaskPoolMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTaskPoolMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveTaskPoolMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveTaskPoolMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveTaskPoolMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveTaskPoolMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTaskPoolMethod "join" o = TaskPoolJoinMethodInfo
    ResolveTaskPoolMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTaskPoolMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTaskPoolMethod "prepare" o = TaskPoolPrepareMethodInfo
    ResolveTaskPoolMethod "push" o = TaskPoolPushMethodInfo
    ResolveTaskPoolMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveTaskPoolMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTaskPoolMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveTaskPoolMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTaskPoolMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTaskPoolMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTaskPoolMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveTaskPoolMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveTaskPoolMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTaskPoolMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveTaskPoolMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveTaskPoolMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTaskPoolMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveTaskPoolMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveTaskPoolMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTaskPoolMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveTaskPoolMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveTaskPoolMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveTaskPoolMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveTaskPoolMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTaskPoolMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTaskPoolMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveTaskPoolMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveTaskPoolMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveTaskPoolMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveTaskPoolMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTaskPoolMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTaskPoolMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveTaskPoolMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveTaskPoolMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTaskPoolMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTaskPoolMethod t TaskPool, O.MethodInfo info TaskPool p) => OL.IsLabel t (TaskPool -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TaskPool
type instance O.AttributeList TaskPool = TaskPoolAttributeList
type TaskPoolAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TaskPool = TaskPoolSignalList
type TaskPoolSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method TaskPool::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "TaskPool" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_task_pool_new" gst_task_pool_new :: 
    IO (Ptr TaskPool)

-- | Create a new default task pool. The default task pool will use a regular
-- GThreadPool for threads.
taskPoolNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TaskPool
    -- ^ __Returns:__ a new t'GI.Gst.Objects.TaskPool.TaskPool'. 'GI.Gst.Objects.Object.objectUnref' after usage.
taskPoolNew :: m TaskPool
taskPoolNew  = IO TaskPool -> m TaskPool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskPool -> m TaskPool) -> IO TaskPool -> m TaskPool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TaskPool
result <- IO (Ptr TaskPool)
gst_task_pool_new
    Text -> Ptr TaskPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"taskPoolNew" Ptr TaskPool
result
    TaskPool
result' <- ((ManagedPtr TaskPool -> TaskPool) -> Ptr TaskPool -> IO TaskPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TaskPool -> TaskPool
TaskPool) Ptr TaskPool
result
    TaskPool -> IO TaskPool
forall (m :: * -> *) a. Monad m => a -> m a
return TaskPool
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method TaskPool::cleanup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTaskPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_task_pool_cleanup" gst_task_pool_cleanup :: 
    Ptr TaskPool ->                         -- pool : TInterface (Name {namespace = "Gst", name = "TaskPool"})
    IO ()

-- | Wait for all tasks to be stopped. This is mainly used internally
-- to ensure proper cleanup of internal data structures in test suites.
-- 
-- MT safe.
taskPoolCleanup ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> m ()
taskPoolCleanup :: a -> m ()
taskPoolCleanup a
pool = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TaskPool
pool' <- a -> IO (Ptr TaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    Ptr TaskPool -> IO ()
gst_task_pool_cleanup Ptr TaskPool
pool'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TaskPoolCleanupMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTaskPool a) => O.MethodInfo TaskPoolCleanupMethodInfo a signature where
    overloadedMethod = taskPoolCleanup

#endif

-- method TaskPool::join
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTaskPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "id"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_task_pool_join" gst_task_pool_join :: 
    Ptr TaskPool ->                         -- pool : TInterface (Name {namespace = "Gst", name = "TaskPool"})
    Ptr () ->                               -- id : TBasicType TPtr
    IO ()

-- | Join a task and\/or return it to the pool. /@id@/ is the id obtained from
-- 'GI.Gst.Objects.TaskPool.taskPoolPush'.
taskPoolJoin ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> Ptr ()
    -- ^ /@id@/: the id
    -> m ()
taskPoolJoin :: a -> Ptr () -> m ()
taskPoolJoin a
pool Ptr ()
id = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TaskPool
pool' <- a -> IO (Ptr TaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    Ptr TaskPool -> Ptr () -> IO ()
gst_task_pool_join Ptr TaskPool
pool' Ptr ()
id
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TaskPoolJoinMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTaskPool a) => O.MethodInfo TaskPoolJoinMethodInfo a signature where
    overloadedMethod = taskPoolJoin

#endif

-- method TaskPool::prepare
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTaskPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : True
-- Skip return : False

foreign import ccall "gst_task_pool_prepare" gst_task_pool_prepare :: 
    Ptr TaskPool ->                         -- pool : TInterface (Name {namespace = "Gst", name = "TaskPool"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

-- | Prepare the taskpool for accepting 'GI.Gst.Objects.TaskPool.taskPoolPush' operations.
-- 
-- MT safe.
taskPoolPrepare ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
taskPoolPrepare :: a -> m ()
taskPoolPrepare a
pool = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TaskPool
pool' <- a -> IO (Ptr TaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr TaskPool -> Ptr (Ptr GError) -> IO ()
gst_task_pool_prepare Ptr TaskPool
pool'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TaskPoolPrepareMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTaskPool a) => O.MethodInfo TaskPoolPrepareMethodInfo a signature where
    overloadedMethod = taskPoolPrepare

#endif

-- method TaskPool::push
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstTaskPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TaskPoolFunction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the function to call"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : True
-- Skip return : False

foreign import ccall "gst_task_pool_push" gst_task_pool_push :: 
    Ptr TaskPool ->                         -- pool : TInterface (Name {namespace = "Gst", name = "TaskPool"})
    FunPtr Gst.Callbacks.C_TaskPoolFunction -> -- func : TInterface (Name {namespace = "Gst", name = "TaskPoolFunction"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr ())

-- | Start the execution of a new thread from /@pool@/.
taskPoolPush ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> Gst.Callbacks.TaskPoolFunction
    -- ^ /@func@/: the function to call
    -> m (Ptr ())
    -- ^ __Returns:__ a pointer that should be used
    -- for the gst_task_pool_join function. This pointer can be 'P.Nothing', you
    -- must check /@error@/ to detect errors. /(Can throw 'Data.GI.Base.GError.GError')/
taskPoolPush :: a -> IO () -> m (Ptr ())
taskPoolPush a
pool IO ()
func = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr TaskPool
pool' <- a -> IO (Ptr TaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    Ptr (FunPtr (Ptr () -> IO ()))
ptrfunc <- IO (Ptr (FunPtr (Ptr () -> IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gst.Callbacks.C_TaskPoolFunction))
    FunPtr (Ptr () -> IO ())
func' <- (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
Gst.Callbacks.mk_TaskPoolFunction (Maybe (Ptr (FunPtr (Ptr () -> IO ())))
-> (Ptr () -> IO ()) -> Ptr () -> IO ()
Gst.Callbacks.wrap_TaskPoolFunction (Ptr (FunPtr (Ptr () -> IO ()))
-> Maybe (Ptr (FunPtr (Ptr () -> IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (Ptr () -> IO ()))
ptrfunc) (IO () -> Ptr () -> IO ()
Gst.Callbacks.drop_closures_TaskPoolFunction IO ()
func))
    Ptr (FunPtr (Ptr () -> IO ())) -> FunPtr (Ptr () -> IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (Ptr () -> IO ()))
ptrfunc FunPtr (Ptr () -> IO ())
func'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    IO (Ptr ()) -> IO () -> IO (Ptr ())
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr ()
result <- (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ Ptr TaskPool
-> FunPtr (Ptr () -> IO ())
-> Ptr ()
-> Ptr (Ptr GError)
-> IO (Ptr ())
gst_task_pool_push Ptr TaskPool
pool' FunPtr (Ptr () -> IO ())
func' Ptr ()
forall a. Ptr a
userData
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
        Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TaskPoolPushMethodInfo
instance (signature ~ (Gst.Callbacks.TaskPoolFunction -> m (Ptr ())), MonadIO m, IsTaskPool a) => O.MethodInfo TaskPoolPushMethodInfo a signature where
    overloadedMethod = taskPoolPush

#endif