{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [cleanup]("GI.Gst.Objects.TaskPool#g:method:cleanup"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [disposeHandle]("GI.Gst.Objects.TaskPool#g:method:disposeHandle"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [join]("GI.Gst.Objects.TaskPool#g:method:join"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [prepare]("GI.Gst.Objects.TaskPool#g:method:prepare"), [push]("GI.Gst.Objects.TaskPool#g:method:push"), [ref]("GI.Gst.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveTaskPoolMethod                   ,
#endif

-- ** cleanup #method:cleanup#

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


-- ** disposeHandle #method:disposeHandle#

#if defined(ENABLE_OVERLOADING)
    TaskPoolDisposeHandleMethodInfo         ,
#endif
    taskPoolDisposeHandle                   ,


-- ** 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.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
$c== :: TaskPool -> TaskPool -> Bool
== :: TaskPool -> TaskPool -> Bool
$c/= :: TaskPool -> TaskPool -> Bool
/= :: 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

-- | 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 :: (MIO.MonadIO m, IsTaskPool o) => o -> m TaskPool
toTaskPool :: forall (m :: * -> *) o.
(MonadIO m, IsTaskPool o) =>
o -> m TaskPool
toTaskPool = IO TaskPool -> m TaskPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr TaskPool -> TaskPool
TaskPool

-- | Convert 'TaskPool' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe TaskPool) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_task_pool_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TaskPool -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TaskPool
P.Nothing = Ptr GValue -> Ptr TaskPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TaskPool
forall a. Ptr a
FP.nullPtr :: FP.Ptr TaskPool)
    gvalueSet_ Ptr GValue
gv (P.Just TaskPool
obj) = TaskPool -> (Ptr TaskPool -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TaskPool
obj (Ptr GValue -> Ptr TaskPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TaskPool)
gvalueGet_ Ptr GValue
gv = do
        Ptr TaskPool
ptr <- Ptr GValue -> IO (Ptr TaskPool)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TaskPool)
        if Ptr TaskPool
ptr Ptr TaskPool -> Ptr TaskPool -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TaskPool
forall a. Ptr a
FP.nullPtr
        then TaskPool -> Maybe TaskPool
forall a. a -> Maybe a
P.Just (TaskPool -> Maybe TaskPool) -> IO TaskPool -> IO (Maybe TaskPool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe TaskPool -> IO (Maybe TaskPool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TaskPool
forall a. Maybe a
P.Nothing
        
    

#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 "disposeHandle" o = TaskPoolDisposeHandleMethodInfo
    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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTaskPoolMethod t TaskPool, O.OverloadedMethod info TaskPool p, R.HasField t TaskPool p) => R.HasField t TaskPool p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTaskPoolMethod t TaskPool, O.OverloadedMethodInfo info TaskPool) => OL.IsLabel t (O.MethodProxy info TaskPool) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TaskPool
taskPoolNew  = IO TaskPool -> m TaskPool
forall a. IO a -> m a
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 a. a -> IO a
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTaskPool a) =>
a -> m ()
taskPoolCleanup a
pool = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TaskPoolCleanupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.TaskPool.taskPoolCleanup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-TaskPool.html#v:taskPoolCleanup"
        })


#endif

-- method TaskPool::dispose_handle
-- 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 = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Dispose of the handle returned by 'GI.Gst.Objects.TaskPool.taskPoolPush'. This does
-- not need to be called with the default implementation as the default
-- t'GI.Gst.Structs.TaskPoolClass.TaskPoolClass'::@/push/@ implementation always returns 'P.Nothing'. This does not need to be
-- called either when calling 'GI.Gst.Objects.TaskPool.taskPoolJoin', but should be called
-- when joining is not necessary, but 'GI.Gst.Objects.TaskPool.taskPoolPush' returned a
-- non-'P.Nothing' value.
-- 
-- This method should only be called with the same /@pool@/ instance that provided
-- /@id@/.
-- 
-- /Since: 1.20/
taskPoolDisposeHandle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> Ptr ()
    -- ^ /@id@/: the id
    -> m ()
taskPoolDisposeHandle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTaskPool a) =>
a -> Ptr () -> m ()
taskPoolDisposeHandle a
pool Ptr ()
id = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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_dispose_handle Ptr TaskPool
pool' Ptr ()
id
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TaskPoolDisposeHandleMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTaskPool a) => O.OverloadedMethod TaskPoolDisposeHandleMethodInfo a signature where
    overloadedMethod = taskPoolDisposeHandle

instance O.OverloadedMethodInfo TaskPoolDisposeHandleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.TaskPool.taskPoolDisposeHandle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-TaskPool.html#v:taskPoolDisposeHandle"
        })


#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 = TransferEverything
--           }
--       ]
-- 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'. The default implementation does nothing, as the
-- default t'GI.Gst.Structs.TaskPoolClass.TaskPoolClass'::@/push/@ implementation always returns 'P.Nothing'.
-- 
-- This method should only be called with the same /@pool@/ instance that provided
-- /@id@/.
taskPoolJoin ::
    (B.CallStack.HasCallStack, MonadIO m, IsTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.TaskPool.TaskPool'
    -> Ptr ()
    -- ^ /@id@/: the id
    -> m ()
taskPoolJoin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTaskPool a) =>
a -> Ptr () -> m ()
taskPoolJoin a
pool Ptr ()
id = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TaskPoolJoinMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.TaskPool.taskPoolJoin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-TaskPool.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTaskPool a) =>
a -> m ()
taskPoolPrepare a
pool = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

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

instance O.OverloadedMethodInfo TaskPoolPrepareMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.TaskPool.taskPoolPrepare",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-TaskPool.html#v: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. If the pointer is not 'P.Nothing' and
    -- 'GI.Gst.Objects.TaskPool.taskPoolJoin' is not used, call 'GI.Gst.Objects.TaskPool.taskPoolDisposeHandle'
    -- instead. /(Can throw 'Data.GI.Base.GError.GError')/
taskPoolPush :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTaskPool a) =>
a -> IO () -> m (Ptr ())
taskPoolPush a
pool IO ()
func = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
     ) (do
        () -> IO ()
forall a. a -> IO a
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.OverloadedMethod TaskPoolPushMethodInfo a signature where
    overloadedMethod = taskPoolPush

instance O.OverloadedMethodInfo TaskPoolPushMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.TaskPool.taskPoolPush",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-TaskPool.html#v:taskPoolPush"
        })


#endif