{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.HashTableIter
(
HashTableIter(..) ,
newZeroHashTableIter ,
#if defined(ENABLE_OVERLOADING)
ResolveHashTableIterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
HashTableIterInitMethodInfo ,
#endif
hashTableIterInit ,
#if defined(ENABLE_OVERLOADING)
HashTableIterNextMethodInfo ,
#endif
hashTableIterNext ,
#if defined(ENABLE_OVERLOADING)
HashTableIterRemoveMethodInfo ,
#endif
hashTableIterRemove ,
#if defined(ENABLE_OVERLOADING)
HashTableIterReplaceMethodInfo ,
#endif
hashTableIterReplace ,
#if defined(ENABLE_OVERLOADING)
HashTableIterStealMethodInfo ,
#endif
hashTableIterSteal ,
) 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
newtype HashTableIter = HashTableIter (SP.ManagedPtr HashTableIter)
deriving (HashTableIter -> HashTableIter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HashTableIter -> HashTableIter -> Bool
$c/= :: HashTableIter -> HashTableIter -> Bool
== :: HashTableIter -> HashTableIter -> Bool
$c== :: HashTableIter -> HashTableIter -> Bool
Eq)
instance SP.ManagedPtrNewtype HashTableIter where
toManagedPtr :: HashTableIter -> ManagedPtr HashTableIter
toManagedPtr (HashTableIter ManagedPtr HashTableIter
p) = ManagedPtr HashTableIter
p
instance BoxedPtr HashTableIter where
boxedPtrCopy :: HashTableIter -> IO HashTableIter
boxedPtrCopy = \HashTableIter
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HashTableIter
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 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 HashTableIter -> HashTableIter
HashTableIter)
boxedPtrFree :: HashTableIter -> IO ()
boxedPtrFree = \HashTableIter
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr HashTableIter
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr HashTableIter where
boxedPtrCalloc :: IO (Ptr HashTableIter)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
24
newZeroHashTableIter :: MonadIO m => m HashTableIter
newZeroHashTableIter :: forall (m :: * -> *). MonadIO m => m HashTableIter
newZeroHashTableIter = 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 HashTableIter -> HashTableIter
HashTableIter
instance tag ~ 'AttrSet => Constructible HashTableIter tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr HashTableIter -> HashTableIter)
-> [AttrOp HashTableIter tag] -> m HashTableIter
new ManagedPtr HashTableIter -> HashTableIter
_ [AttrOp HashTableIter tag]
attrs = do
HashTableIter
o <- forall (m :: * -> *). MonadIO m => m HashTableIter
newZeroHashTableIter
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set HashTableIter
o [AttrOp HashTableIter tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return HashTableIter
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList HashTableIter
type instance O.AttributeList HashTableIter = HashTableIterAttributeList
type HashTableIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "g_hash_table_iter_init" g_hash_table_iter_init ::
Ptr HashTableIter ->
Ptr (GHashTable (Ptr ()) (Ptr ())) ->
IO ()
hashTableIterInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
HashTableIter
-> Map.Map (Ptr ()) (Ptr ())
-> m ()
hashTableIterInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HashTableIter -> Map (Ptr ()) (Ptr ()) -> m ()
hashTableIterInit HashTableIter
iter Map (Ptr ()) (Ptr ())
hashTable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HashTableIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HashTableIter
iter
let hashTable' :: [(Ptr (), Ptr ())]
hashTable' = forall k a. Map k a -> [(k, a)]
Map.toList Map (Ptr ()) (Ptr ())
hashTable
let hashTable'' :: [(PtrWrapped (Ptr ()), Ptr ())]
hashTable'' = forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(Ptr (), Ptr ())]
hashTable'
let hashTable''' :: [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
hashTable''' = forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(PtrWrapped (Ptr ()), Ptr ())]
hashTable''
Ptr (GHashTable (Ptr ()) (Ptr ()))
hashTable'''' <- forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable forall a. GHashFunc (Ptr a)
gDirectHash forall a. GEqualFunc (Ptr a)
gDirectEqual forall a. Maybe a
Nothing forall a. Maybe a
Nothing [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
hashTable'''
Ptr HashTableIter -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
g_hash_table_iter_init Ptr HashTableIter
iter' Ptr (GHashTable (Ptr ()) (Ptr ()))
hashTable''''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HashTableIter
iter
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
hashTable''''
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HashTableIterInitMethodInfo
instance (signature ~ (Map.Map (Ptr ()) (Ptr ()) -> m ()), MonadIO m) => O.OverloadedMethod HashTableIterInitMethodInfo HashTableIter signature where
overloadedMethod = hashTableIterInit
instance O.OverloadedMethodInfo HashTableIterInitMethodInfo HashTableIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HashTableIter.hashTableIterInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HashTableIter.html#v:hashTableIterInit"
})
#endif
foreign import ccall "g_hash_table_iter_next" g_hash_table_iter_next ::
Ptr HashTableIter ->
Ptr (Ptr ()) ->
Ptr (Ptr ()) ->
IO CInt
hashTableIterNext ::
(B.CallStack.HasCallStack, MonadIO m) =>
HashTableIter
-> m ((Bool, Ptr (), Ptr ()))
hashTableIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HashTableIter -> m (Bool, Ptr (), Ptr ())
hashTableIterNext HashTableIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HashTableIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HashTableIter
iter
Ptr (Ptr ())
key <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
Ptr (Ptr ())
value <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
CInt
result <- Ptr HashTableIter -> Ptr (Ptr ()) -> Ptr (Ptr ()) -> IO CInt
g_hash_table_iter_next Ptr HashTableIter
iter' Ptr (Ptr ())
key Ptr (Ptr ())
value
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr ()
key' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
key
Ptr ()
value' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HashTableIter
iter
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
key
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
value
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
key', Ptr ()
value')
#if defined(ENABLE_OVERLOADING)
data HashTableIterNextMethodInfo
instance (signature ~ (m ((Bool, Ptr (), Ptr ()))), MonadIO m) => O.OverloadedMethod HashTableIterNextMethodInfo HashTableIter signature where
overloadedMethod = hashTableIterNext
instance O.OverloadedMethodInfo HashTableIterNextMethodInfo HashTableIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HashTableIter.hashTableIterNext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HashTableIter.html#v:hashTableIterNext"
})
#endif
foreign import ccall "g_hash_table_iter_remove" g_hash_table_iter_remove ::
Ptr HashTableIter ->
IO ()
hashTableIterRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
HashTableIter
-> m ()
hashTableIterRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HashTableIter -> m ()
hashTableIterRemove HashTableIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HashTableIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HashTableIter
iter
Ptr HashTableIter -> IO ()
g_hash_table_iter_remove Ptr HashTableIter
iter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HashTableIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HashTableIterRemoveMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod HashTableIterRemoveMethodInfo HashTableIter signature where
overloadedMethod = hashTableIterRemove
instance O.OverloadedMethodInfo HashTableIterRemoveMethodInfo HashTableIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HashTableIter.hashTableIterRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HashTableIter.html#v:hashTableIterRemove"
})
#endif
foreign import ccall "g_hash_table_iter_replace" g_hash_table_iter_replace ::
Ptr HashTableIter ->
Ptr () ->
IO ()
hashTableIterReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
HashTableIter
-> Ptr ()
-> m ()
hashTableIterReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HashTableIter -> Ptr () -> m ()
hashTableIterReplace HashTableIter
iter Ptr ()
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HashTableIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HashTableIter
iter
Ptr HashTableIter -> Ptr () -> IO ()
g_hash_table_iter_replace Ptr HashTableIter
iter' Ptr ()
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HashTableIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HashTableIterReplaceMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.OverloadedMethod HashTableIterReplaceMethodInfo HashTableIter signature where
overloadedMethod = hashTableIterReplace
instance O.OverloadedMethodInfo HashTableIterReplaceMethodInfo HashTableIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HashTableIter.hashTableIterReplace",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HashTableIter.html#v:hashTableIterReplace"
})
#endif
foreign import ccall "g_hash_table_iter_steal" g_hash_table_iter_steal ::
Ptr HashTableIter ->
IO ()
hashTableIterSteal ::
(B.CallStack.HasCallStack, MonadIO m) =>
HashTableIter
-> m ()
hashTableIterSteal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
HashTableIter -> m ()
hashTableIterSteal HashTableIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr HashTableIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HashTableIter
iter
Ptr HashTableIter -> IO ()
g_hash_table_iter_steal Ptr HashTableIter
iter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HashTableIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data HashTableIterStealMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod HashTableIterStealMethodInfo HashTableIter signature where
overloadedMethod = hashTableIterSteal
instance O.OverloadedMethodInfo HashTableIterStealMethodInfo HashTableIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.HashTableIter.hashTableIterSteal",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-HashTableIter.html#v:hashTableIterSteal"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveHashTableIterMethod (t :: Symbol) (o :: *) :: * where
ResolveHashTableIterMethod "init" o = HashTableIterInitMethodInfo
ResolveHashTableIterMethod "next" o = HashTableIterNextMethodInfo
ResolveHashTableIterMethod "remove" o = HashTableIterRemoveMethodInfo
ResolveHashTableIterMethod "replace" o = HashTableIterReplaceMethodInfo
ResolveHashTableIterMethod "steal" o = HashTableIterStealMethodInfo
ResolveHashTableIterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHashTableIterMethod t HashTableIter, O.OverloadedMethod info HashTableIter p) => OL.IsLabel t (HashTableIter -> 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 ~ ResolveHashTableIterMethod t HashTableIter, O.OverloadedMethod info HashTableIter p, R.HasField t HashTableIter p) => R.HasField t HashTableIter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHashTableIterMethod t HashTableIter, O.OverloadedMethodInfo info HashTableIter) => OL.IsLabel t (O.MethodProxy info HashTableIter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif