{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Gst.Objects.SharedTaskPool.SharedTaskPool' object.
-- 
-- /Since: 1.20/

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

module GI.Gst.Objects.SharedTaskPool
    ( 

-- * Exported types
    SharedTaskPool(..)                      ,
    IsSharedTaskPool                        ,
    toSharedTaskPool                        ,


 -- * 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"), [getMaxThreads]("GI.Gst.Objects.SharedTaskPool#g:method:getMaxThreads"), [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"), [setMaxThreads]("GI.Gst.Objects.SharedTaskPool#g:method:setMaxThreads"), [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)
    ResolveSharedTaskPoolMethod             ,
#endif

-- ** getMaxThreads #method:getMaxThreads#

#if defined(ENABLE_OVERLOADING)
    SharedTaskPoolGetMaxThreadsMethodInfo   ,
#endif
    sharedTaskPoolGetMaxThreads             ,


-- ** new #method:new#

    sharedTaskPoolNew                       ,


-- ** setMaxThreads #method:setMaxThreads#

#if defined(ENABLE_OVERLOADING)
    SharedTaskPoolSetMaxThreadsMethodInfo   ,
#endif
    sharedTaskPoolSetMaxThreads             ,




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

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

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

foreign import ccall "gst_shared_task_pool_get_type"
    c_gst_shared_task_pool_get_type :: IO B.Types.GType

instance B.Types.TypedObject SharedTaskPool where
    glibType :: IO GType
glibType = IO GType
c_gst_shared_task_pool_get_type

instance B.Types.GObject SharedTaskPool

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

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

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

-- | Convert 'SharedTaskPool' 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 SharedTaskPool) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_shared_task_pool_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SharedTaskPool -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SharedTaskPool
P.Nothing = Ptr GValue -> Ptr SharedTaskPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SharedTaskPool
forall a. Ptr a
FP.nullPtr :: FP.Ptr SharedTaskPool)
    gvalueSet_ Ptr GValue
gv (P.Just SharedTaskPool
obj) = SharedTaskPool -> (Ptr SharedTaskPool -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SharedTaskPool
obj (Ptr GValue -> Ptr SharedTaskPool -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SharedTaskPool)
gvalueGet_ Ptr GValue
gv = do
        Ptr SharedTaskPool
ptr <- Ptr GValue -> IO (Ptr SharedTaskPool)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SharedTaskPool)
        if Ptr SharedTaskPool
ptr Ptr SharedTaskPool -> Ptr SharedTaskPool -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SharedTaskPool
forall a. Ptr a
FP.nullPtr
        then SharedTaskPool -> Maybe SharedTaskPool
forall a. a -> Maybe a
P.Just (SharedTaskPool -> Maybe SharedTaskPool)
-> IO SharedTaskPool -> IO (Maybe SharedTaskPool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SharedTaskPool -> SharedTaskPool)
-> Ptr SharedTaskPool -> IO SharedTaskPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SharedTaskPool -> SharedTaskPool
SharedTaskPool Ptr SharedTaskPool
ptr
        else Maybe SharedTaskPool -> IO (Maybe SharedTaskPool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SharedTaskPool
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveSharedTaskPoolMethod t SharedTaskPool, O.OverloadedMethod info SharedTaskPool p) => OL.IsLabel t (SharedTaskPool -> 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 ~ ResolveSharedTaskPoolMethod t SharedTaskPool, O.OverloadedMethod info SharedTaskPool p, R.HasField t SharedTaskPool p) => R.HasField t SharedTaskPool p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveSharedTaskPoolMethod t SharedTaskPool, O.OverloadedMethodInfo info SharedTaskPool) => OL.IsLabel t (O.MethodProxy info SharedTaskPool) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

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

#endif

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

foreign import ccall "gst_shared_task_pool_new" gst_shared_task_pool_new :: 
    IO (Ptr SharedTaskPool)

-- | Create a new shared task pool. The shared task pool will queue tasks on
-- a maximum number of threads, 1 by default.
-- 
-- Do not use a t'GI.Gst.Objects.SharedTaskPool.SharedTaskPool' to manage potentially inter-dependent tasks such
-- as pad tasks, as having one task waiting on another to return before returning
-- would cause obvious deadlocks if they happen to share the same thread.
-- 
-- /Since: 1.20/
sharedTaskPoolNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SharedTaskPool
    -- ^ __Returns:__ a new t'GI.Gst.Objects.SharedTaskPool.SharedTaskPool'. 'GI.Gst.Objects.Object.objectUnref' after usage.
sharedTaskPoolNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m SharedTaskPool
sharedTaskPoolNew  = IO SharedTaskPool -> m SharedTaskPool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SharedTaskPool -> m SharedTaskPool)
-> IO SharedTaskPool -> m SharedTaskPool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SharedTaskPool
result <- IO (Ptr SharedTaskPool)
gst_shared_task_pool_new
    Text -> Ptr SharedTaskPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sharedTaskPoolNew" Ptr SharedTaskPool
result
    SharedTaskPool
result' <- ((ManagedPtr SharedTaskPool -> SharedTaskPool)
-> Ptr SharedTaskPool -> IO SharedTaskPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SharedTaskPool -> SharedTaskPool
SharedTaskPool) Ptr SharedTaskPool
result
    SharedTaskPool -> IO SharedTaskPool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SharedTaskPool
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SharedTaskPool::get_max_threads
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "SharedTaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstSharedTaskPool"
--                 , 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 "gst_shared_task_pool_get_max_threads" gst_shared_task_pool_get_max_threads :: 
    Ptr SharedTaskPool ->                   -- pool : TInterface (Name {namespace = "Gst", name = "SharedTaskPool"})
    IO Word32

-- | /No description available in the introspection data./
-- 
-- /Since: 1.20/
sharedTaskPoolGetMaxThreads ::
    (B.CallStack.HasCallStack, MonadIO m, IsSharedTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.SharedTaskPool.SharedTaskPool'
    -> m Word32
    -- ^ __Returns:__ the maximum number of threads /@pool@/ is configured to spawn
sharedTaskPoolGetMaxThreads :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSharedTaskPool a) =>
a -> m Word32
sharedTaskPoolGetMaxThreads a
pool = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SharedTaskPool
pool' <- a -> IO (Ptr SharedTaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    Word32
result <- Ptr SharedTaskPool -> IO Word32
gst_shared_task_pool_get_max_threads Ptr SharedTaskPool
pool'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pool
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SharedTaskPoolGetMaxThreadsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSharedTaskPool a) => O.OverloadedMethod SharedTaskPoolGetMaxThreadsMethodInfo a signature where
    overloadedMethod = sharedTaskPoolGetMaxThreads

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


#endif

-- method SharedTaskPool::set_max_threads
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "SharedTaskPool" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstSharedTaskPool"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_threads"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Maximum number of threads to spawn."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_shared_task_pool_set_max_threads" gst_shared_task_pool_set_max_threads :: 
    Ptr SharedTaskPool ->                   -- pool : TInterface (Name {namespace = "Gst", name = "SharedTaskPool"})
    Word32 ->                               -- max_threads : TBasicType TUInt
    IO ()

-- | Update the maximal number of threads the /@pool@/ may spawn. When
-- the maximal number of threads is reduced, existing threads are not
-- immediately shut down, see 'GI.GLib.Structs.ThreadPool.threadPoolSetMaxThreads'.
-- 
-- Setting /@maxThreads@/ to 0 effectively freezes the pool.
-- 
-- /Since: 1.20/
sharedTaskPoolSetMaxThreads ::
    (B.CallStack.HasCallStack, MonadIO m, IsSharedTaskPool a) =>
    a
    -- ^ /@pool@/: a t'GI.Gst.Objects.SharedTaskPool.SharedTaskPool'
    -> Word32
    -- ^ /@maxThreads@/: Maximum number of threads to spawn.
    -> m ()
sharedTaskPoolSetMaxThreads :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSharedTaskPool a) =>
a -> Word32 -> m ()
sharedTaskPoolSetMaxThreads a
pool Word32
maxThreads = 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 SharedTaskPool
pool' <- a -> IO (Ptr SharedTaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pool
    Ptr SharedTaskPool -> Word32 -> IO ()
gst_shared_task_pool_set_max_threads Ptr SharedTaskPool
pool' Word32
maxThreads
    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 SharedTaskPoolSetMaxThreadsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSharedTaskPool a) => O.OverloadedMethod SharedTaskPoolSetMaxThreadsMethodInfo a signature where
    overloadedMethod = sharedTaskPoolSetMaxThreads

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


#endif