{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Once
(
Once(..) ,
newZeroOnce ,
#if defined(ENABLE_OVERLOADING)
ResolveOnceMethod ,
#endif
onceInitEnter ,
onceInitLeave ,
clearOnceRetval ,
getOnceRetval ,
#if defined(ENABLE_OVERLOADING)
once_retval ,
#endif
setOnceRetval ,
getOnceStatus ,
#if defined(ENABLE_OVERLOADING)
once_status ,
#endif
setOnceStatus ,
) 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 {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
newtype Once = Once (SP.ManagedPtr Once)
deriving (Once -> Once -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Once -> Once -> Bool
$c/= :: Once -> Once -> Bool
== :: Once -> Once -> Bool
$c== :: Once -> Once -> Bool
Eq)
instance SP.ManagedPtrNewtype Once where
toManagedPtr :: Once -> ManagedPtr Once
toManagedPtr (Once ManagedPtr Once
p) = ManagedPtr Once
p
instance BoxedPtr Once where
boxedPtrCopy :: Once -> IO Once
boxedPtrCopy = \Once
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Once
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
8 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Once -> Once
Once)
boxedPtrFree :: Once -> IO ()
boxedPtrFree = \Once
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Once
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Once where
boxedPtrCalloc :: IO (Ptr Once)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
8
newZeroOnce :: MonadIO m => m Once
newZeroOnce :: forall (m :: * -> *). MonadIO m => m Once
newZeroOnce = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Once -> Once
Once
instance tag ~ 'AttrSet => Constructible Once tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Once -> Once) -> [AttrOp Once tag] -> m Once
new ManagedPtr Once -> Once
_ [AttrOp Once tag]
attrs = do
Once
o <- forall (m :: * -> *). MonadIO m => m Once
newZeroOnce
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Once
o [AttrOp Once tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return Once
o
getOnceStatus :: MonadIO m => Once -> m GLib.Enums.OnceStatus
getOnceStatus :: forall (m :: * -> *). MonadIO m => Once -> m OnceStatus
getOnceStatus Once
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Once
s forall a b. (a -> b) -> a -> b
$ \Ptr Once
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Once
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CUInt
let val' :: OnceStatus
val' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return OnceStatus
val'
setOnceStatus :: MonadIO m => Once -> GLib.Enums.OnceStatus -> m ()
setOnceStatus :: forall (m :: * -> *). MonadIO m => Once -> OnceStatus -> m ()
setOnceStatus Once
s OnceStatus
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Once
s forall a b. (a -> b) -> a -> b
$ \Ptr Once
ptr -> do
let val' :: CUInt
val' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) OnceStatus
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Once
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data OnceStatusFieldInfo
instance AttrInfo OnceStatusFieldInfo where
type AttrBaseTypeConstraint OnceStatusFieldInfo = (~) Once
type AttrAllowedOps OnceStatusFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint OnceStatusFieldInfo = (~) GLib.Enums.OnceStatus
type AttrTransferTypeConstraint OnceStatusFieldInfo = (~)GLib.Enums.OnceStatus
type AttrTransferType OnceStatusFieldInfo = GLib.Enums.OnceStatus
type AttrGetType OnceStatusFieldInfo = GLib.Enums.OnceStatus
type AttrLabel OnceStatusFieldInfo = "status"
type AttrOrigin OnceStatusFieldInfo = Once
attrGet = getOnceStatus
attrSet = setOnceStatus
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Once.status"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Once.html#g:attr:status"
})
once_status :: AttrLabelProxy "status"
once_status = AttrLabelProxy
#endif
getOnceRetval :: MonadIO m => Once -> m (Ptr ())
getOnceRetval :: forall (m :: * -> *). MonadIO m => Once -> m (Ptr ())
getOnceRetval Once
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Once
s forall a b. (a -> b) -> a -> b
$ \Ptr Once
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Once
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setOnceRetval :: MonadIO m => Once -> Ptr () -> m ()
setOnceRetval :: forall (m :: * -> *). MonadIO m => Once -> Ptr () -> m ()
setOnceRetval Once
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Once
s forall a b. (a -> b) -> a -> b
$ \Ptr Once
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Once
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr ()
val :: Ptr ())
clearOnceRetval :: MonadIO m => Once -> m ()
clearOnceRetval :: forall (m :: * -> *). MonadIO m => Once -> m ()
clearOnceRetval Once
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Once
s forall a b. (a -> b) -> a -> b
$ \Ptr Once
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Once
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data OnceRetvalFieldInfo
instance AttrInfo OnceRetvalFieldInfo where
type AttrBaseTypeConstraint OnceRetvalFieldInfo = (~) Once
type AttrAllowedOps OnceRetvalFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint OnceRetvalFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint OnceRetvalFieldInfo = (~)(Ptr ())
type AttrTransferType OnceRetvalFieldInfo = (Ptr ())
type AttrGetType OnceRetvalFieldInfo = Ptr ()
type AttrLabel OnceRetvalFieldInfo = "retval"
type AttrOrigin OnceRetvalFieldInfo = Once
attrGet = getOnceRetval
attrSet = setOnceRetval
attrConstruct = undefined
attrClear = clearOnceRetval
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Once.retval"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Once.html#g:attr:retval"
})
once_retval :: AttrLabelProxy "retval"
once_retval = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Once
type instance O.AttributeList Once = OnceAttributeList
type OnceAttributeList = ('[ '("status", OnceStatusFieldInfo), '("retval", OnceRetvalFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_once_init_enter" g_once_init_enter ::
Ptr () ->
IO CInt
onceInitEnter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m Bool
onceInitEnter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m Bool
onceInitEnter Ptr ()
location = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CInt
result <- Ptr () -> IO CInt
g_once_init_enter Ptr ()
location
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_once_init_leave" g_once_init_leave ::
Ptr () ->
Word32 ->
IO ()
onceInitLeave ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Word32
-> m ()
onceInitLeave :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Word32 -> m ()
onceInitLeave Ptr ()
location Word32
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr () -> Word32 -> IO ()
g_once_init_leave Ptr ()
location Word32
result_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveOnceMethod (t :: Symbol) (o :: *) :: * where
ResolveOnceMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveOnceMethod t Once, O.OverloadedMethod info Once p) => OL.IsLabel t (Once -> 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 ~ ResolveOnceMethod t Once, O.OverloadedMethod info Once p, R.HasField t Once p) => R.HasField t Once p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveOnceMethod t Once, O.OverloadedMethodInfo info Once) => OL.IsLabel t (O.MethodProxy info Once) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif