{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Thread
(
Thread(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveThreadMethod ,
#endif
threadErrorQuark ,
threadExit ,
#if defined(ENABLE_OVERLOADING)
ThreadJoinMethodInfo ,
#endif
threadJoin ,
threadNew ,
#if defined(ENABLE_OVERLOADING)
ThreadRefMethodInfo ,
#endif
threadRef ,
threadSelf ,
threadTryNew ,
#if defined(ENABLE_OVERLOADING)
ThreadUnrefMethodInfo ,
#endif
threadUnref ,
threadYield ,
) 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.Kind as DK
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.GLib.Callbacks as GLib.Callbacks
newtype Thread = Thread (SP.ManagedPtr Thread)
deriving (Thread -> Thread -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Thread -> Thread -> Bool
$c/= :: Thread -> Thread -> Bool
== :: Thread -> Thread -> Bool
$c== :: Thread -> Thread -> Bool
Eq)
instance SP.ManagedPtrNewtype Thread where
toManagedPtr :: Thread -> ManagedPtr Thread
toManagedPtr (Thread ManagedPtr Thread
p) = ManagedPtr Thread
p
foreign import ccall "g_thread_get_type" c_g_thread_get_type ::
IO GType
type instance O.ParentTypes Thread = '[]
instance O.HasParentTypes Thread
instance B.Types.TypedObject Thread where
glibType :: IO GType
glibType = IO GType
c_g_thread_get_type
instance B.Types.GBoxed Thread
instance B.GValue.IsGValue (Maybe Thread) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_thread_get_type
gvalueSet_ :: Ptr GValue -> Maybe Thread -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Thread
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Thread)
gvalueSet_ Ptr GValue
gv (P.Just Thread
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Thread
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Thread)
gvalueGet_ Ptr GValue
gv = do
Ptr Thread
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Thread)
if Ptr Thread
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Thread -> Thread
Thread Ptr Thread
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Thread
type instance O.AttributeList Thread = ThreadAttributeList
type ThreadAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_thread_new" g_thread_new ::
CString ->
FunPtr GLib.Callbacks.C_ThreadFunc ->
Ptr () ->
IO (Ptr Thread)
threadNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> GLib.Callbacks.ThreadFunc
-> m Thread
threadNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> ThreadFunc -> m Thread
threadNew Maybe Text
name ThreadFunc
func = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr (FunPtr ThreadFunc)
ptrfunc <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_ThreadFunc))
FunPtr ThreadFunc
func' <- ThreadFunc -> IO (FunPtr ThreadFunc)
GLib.Callbacks.mk_ThreadFunc (Maybe (Ptr (FunPtr ThreadFunc)) -> ThreadFunc -> ThreadFunc
GLib.Callbacks.wrap_ThreadFunc (forall a. a -> Maybe a
Just Ptr (FunPtr ThreadFunc)
ptrfunc) ThreadFunc
func)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr ThreadFunc)
ptrfunc FunPtr ThreadFunc
func'
let data_ :: Ptr a
data_ = forall a. Ptr a
nullPtr
Ptr Thread
result <- Ptr CChar -> FunPtr ThreadFunc -> Ptr () -> IO (Ptr Thread)
g_thread_new Ptr CChar
maybeName FunPtr ThreadFunc
func' forall a. Ptr a
data_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadNew" Ptr Thread
result
Thread
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_try_new" g_thread_try_new ::
CString ->
FunPtr GLib.Callbacks.C_ThreadFunc ->
Ptr () ->
Ptr (Ptr GError) ->
IO (Ptr Thread)
threadTryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> GLib.Callbacks.ThreadFunc
-> m Thread
threadTryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> ThreadFunc -> m Thread
threadTryNew Maybe Text
name ThreadFunc
func = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr (FunPtr ThreadFunc)
ptrfunc <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_ThreadFunc))
FunPtr ThreadFunc
func' <- ThreadFunc -> IO (FunPtr ThreadFunc)
GLib.Callbacks.mk_ThreadFunc (Maybe (Ptr (FunPtr ThreadFunc)) -> ThreadFunc -> ThreadFunc
GLib.Callbacks.wrap_ThreadFunc (forall a. a -> Maybe a
Just Ptr (FunPtr ThreadFunc)
ptrfunc) ThreadFunc
func)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr ThreadFunc)
ptrfunc FunPtr ThreadFunc
func'
let data_ :: Ptr a
data_ = forall a. Ptr a
nullPtr
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Thread
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> FunPtr ThreadFunc
-> Ptr ()
-> Ptr (Ptr GError)
-> IO (Ptr Thread)
g_thread_try_new Ptr CChar
maybeName FunPtr ThreadFunc
func' forall a. Ptr a
data_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadTryNew" Ptr Thread
result
Thread
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
) (do
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_join" g_thread_join ::
Ptr Thread ->
IO (Ptr ())
threadJoin ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m (Ptr ())
threadJoin :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Thread -> m (Ptr ())
threadJoin Thread
thread = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Thread
thread
Ptr ()
result <- Ptr Thread -> IO (Ptr ())
g_thread_join Ptr Thread
thread'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ThreadJoinMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod ThreadJoinMethodInfo Thread signature where
overloadedMethod = threadJoin
instance O.OverloadedMethodInfo ThreadJoinMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadJoin",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Thread.html#v:threadJoin"
})
#endif
foreign import ccall "g_thread_ref" g_thread_ref ::
Ptr Thread ->
IO (Ptr Thread)
threadRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m Thread
threadRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Thread -> m Thread
threadRef Thread
thread = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Thread
thread
Ptr Thread
result <- Ptr Thread -> IO (Ptr Thread)
g_thread_ref Ptr Thread
thread'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadRef" Ptr Thread
result
Thread
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
data ThreadRefMethodInfo
instance (signature ~ (m Thread), MonadIO m) => O.OverloadedMethod ThreadRefMethodInfo Thread signature where
overloadedMethod = threadRef
instance O.OverloadedMethodInfo ThreadRefMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Thread.html#v:threadRef"
})
#endif
foreign import ccall "g_thread_unref" g_thread_unref ::
Ptr Thread ->
IO ()
threadUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m ()
threadUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Thread -> m ()
threadUnref Thread
thread = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Thread
thread
Ptr Thread -> IO ()
g_thread_unref Ptr Thread
thread'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ThreadUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ThreadUnrefMethodInfo Thread signature where
overloadedMethod = threadUnref
instance O.OverloadedMethodInfo ThreadUnrefMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Thread.html#v:threadUnref"
})
#endif
foreign import ccall "g_thread_error_quark" g_thread_error_quark ::
IO Word32
threadErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
threadErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
threadErrorQuark = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
g_thread_error_quark
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_exit" g_thread_exit ::
Ptr () ->
IO ()
threadExit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m ()
threadExit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
threadExit Ptr ()
retval = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr () -> IO ()
g_thread_exit Ptr ()
retval
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_self" g_thread_self ::
IO (Ptr Thread)
threadSelf ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Thread
threadSelf :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Thread
threadSelf = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
result <- IO (Ptr Thread)
g_thread_self
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadSelf" Ptr Thread
result
Thread
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_yield" g_thread_yield ::
IO ()
threadYield ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
threadYield :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
threadYield = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
IO ()
g_thread_yield
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveThreadMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveThreadMethod "join" o = ThreadJoinMethodInfo
ResolveThreadMethod "ref" o = ThreadRefMethodInfo
ResolveThreadMethod "unref" o = ThreadUnrefMethodInfo
ResolveThreadMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveThreadMethod t Thread, O.OverloadedMethod info Thread p) => OL.IsLabel t (Thread -> 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 ~ ResolveThreadMethod t Thread, O.OverloadedMethod info Thread p, R.HasField t Thread p) => R.HasField t Thread p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveThreadMethod t Thread, O.OverloadedMethodInfo info Thread) => OL.IsLabel t (O.MethodProxy info Thread) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif