{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Dazzle.Structs.Trie
(
Trie(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveTrieMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TrieDestroyMethodInfo ,
#endif
trieDestroy ,
#if defined(ENABLE_OVERLOADING)
TrieInsertMethodInfo ,
#endif
trieInsert ,
#if defined(ENABLE_OVERLOADING)
TrieLookupMethodInfo ,
#endif
trieLookup ,
trieNew ,
#if defined(ENABLE_OVERLOADING)
TrieRefMethodInfo ,
#endif
trieRef ,
#if defined(ENABLE_OVERLOADING)
TrieRemoveMethodInfo ,
#endif
trieRemove ,
#if defined(ENABLE_OVERLOADING)
TrieTraverseMethodInfo ,
#endif
trieTraverse ,
#if defined(ENABLE_OVERLOADING)
TrieUnrefMethodInfo ,
#endif
trieUnref ,
) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GLib.Flags as GLib.Flags
#else
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GLib.Flags as GLib.Flags
#endif
newtype Trie = Trie (SP.ManagedPtr Trie)
deriving (Trie -> Trie -> Bool
(Trie -> Trie -> Bool) -> (Trie -> Trie -> Bool) -> Eq Trie
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Trie -> Trie -> Bool
== :: Trie -> Trie -> Bool
$c/= :: Trie -> Trie -> Bool
/= :: Trie -> Trie -> Bool
Eq)
instance SP.ManagedPtrNewtype Trie where
toManagedPtr :: Trie -> ManagedPtr Trie
toManagedPtr (Trie ManagedPtr Trie
p) = ManagedPtr Trie
p
foreign import ccall "dzl_trie_get_type" c_dzl_trie_get_type ::
IO GType
type instance O.ParentTypes Trie = '[]
instance O.HasParentTypes Trie
instance B.Types.TypedObject Trie where
glibType :: IO GType
glibType = IO GType
c_dzl_trie_get_type
instance B.Types.GBoxed Trie
instance B.GValue.IsGValue (Maybe Trie) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_trie_get_type
gvalueSet_ :: Ptr GValue -> Maybe Trie -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Trie
P.Nothing = Ptr GValue -> Ptr Trie -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Trie
forall a. Ptr a
FP.nullPtr :: FP.Ptr Trie)
gvalueSet_ Ptr GValue
gv (P.Just Trie
obj) = Trie -> (Ptr Trie -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Trie
obj (Ptr GValue -> Ptr Trie -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Trie)
gvalueGet_ Ptr GValue
gv = do
Ptr Trie
ptr <- Ptr GValue -> IO (Ptr Trie)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Trie)
if Ptr Trie
ptr Ptr Trie -> Ptr Trie -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Trie
forall a. Ptr a
FP.nullPtr
then Trie -> Maybe Trie
forall a. a -> Maybe a
P.Just (Trie -> Maybe Trie) -> IO Trie -> IO (Maybe Trie)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Trie -> Trie) -> Ptr Trie -> IO Trie
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Trie -> Trie
Trie Ptr Trie
ptr
else Maybe Trie -> IO (Maybe Trie)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Trie
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Trie
type instance O.AttributeList Trie = TrieAttributeList
type TrieAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "dzl_trie_new" dzl_trie_new ::
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr Trie)
trieNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Callbacks.DestroyNotify
-> m Trie
trieNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => IO () -> m Trie
trieNew IO ()
valueDestroy = IO Trie -> m Trie
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Trie -> m Trie) -> IO Trie -> m Trie
forall a b. (a -> b) -> a -> b
$ do
Ptr (FunPtr C_DestroyNotify)
ptrvalueDestroy <- IO (Ptr (FunPtr C_DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr C_DestroyNotify
valueDestroy' <- C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr C_DestroyNotify))
-> C_DestroyNotify -> C_DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr C_DestroyNotify)
-> Maybe (Ptr (FunPtr C_DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr C_DestroyNotify)
ptrvalueDestroy) (IO () -> C_DestroyNotify
GLib.Callbacks.drop_closures_DestroyNotify IO ()
valueDestroy))
Ptr (FunPtr C_DestroyNotify) -> FunPtr C_DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_DestroyNotify)
ptrvalueDestroy FunPtr C_DestroyNotify
valueDestroy'
Ptr Trie
result <- FunPtr C_DestroyNotify -> IO (Ptr Trie)
dzl_trie_new FunPtr C_DestroyNotify
valueDestroy'
Text -> Ptr Trie -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trieNew" Ptr Trie
result
Trie
result' <- ((ManagedPtr Trie -> Trie) -> Ptr Trie -> IO Trie
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Trie -> Trie
Trie) Ptr Trie
result
Trie -> IO Trie
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Trie
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "dzl_trie_destroy" dzl_trie_destroy ::
Ptr Trie ->
IO ()
trieDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> m ()
trieDestroy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Trie -> m ()
trieDestroy Trie
trie = 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 Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
Ptr Trie -> IO ()
dzl_trie_destroy Ptr Trie
trie'
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TrieDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TrieDestroyMethodInfo Trie signature where
overloadedMethod = trieDestroy
instance O.OverloadedMethodInfo TrieDestroyMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieDestroy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieDestroy"
})
#endif
foreign import ccall "dzl_trie_insert" dzl_trie_insert ::
Ptr Trie ->
CString ->
Ptr () ->
IO ()
trieInsert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> T.Text
-> Ptr ()
-> m ()
trieInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Trie -> Text -> Ptr () -> m ()
trieInsert Trie
trie Text
key Ptr ()
value = 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 Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr Trie -> CString -> C_DestroyNotify
dzl_trie_insert Ptr Trie
trie' CString
key' Ptr ()
value
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TrieInsertMethodInfo
instance (signature ~ (T.Text -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod TrieInsertMethodInfo Trie signature where
overloadedMethod = trieInsert
instance O.OverloadedMethodInfo TrieInsertMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieInsert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieInsert"
})
#endif
foreign import ccall "dzl_trie_lookup" dzl_trie_lookup ::
Ptr Trie ->
CString ->
IO (Ptr ())
trieLookup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> T.Text
-> m (Ptr ())
trieLookup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Trie -> Text -> m (Ptr ())
trieLookup Trie
trie Text
key = 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 Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr ()
result <- Ptr Trie -> CString -> IO (Ptr ())
dzl_trie_lookup Ptr Trie
trie' CString
key'
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data TrieLookupMethodInfo
instance (signature ~ (T.Text -> m (Ptr ())), MonadIO m) => O.OverloadedMethod TrieLookupMethodInfo Trie signature where
overloadedMethod = trieLookup
instance O.OverloadedMethodInfo TrieLookupMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieLookup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieLookup"
})
#endif
foreign import ccall "dzl_trie_ref" dzl_trie_ref ::
Ptr Trie ->
IO (Ptr Trie)
trieRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> m Trie
trieRef :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Trie -> m Trie
trieRef Trie
trie = IO Trie -> m Trie
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Trie -> m Trie) -> IO Trie -> m Trie
forall a b. (a -> b) -> a -> b
$ do
Ptr Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
Ptr Trie
result <- Ptr Trie -> IO (Ptr Trie)
dzl_trie_ref Ptr Trie
trie'
Text -> Ptr Trie -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trieRef" Ptr Trie
result
Trie
result' <- ((ManagedPtr Trie -> Trie) -> Ptr Trie -> IO Trie
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Trie -> Trie
Trie) Ptr Trie
result
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
Trie -> IO Trie
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Trie
result'
#if defined(ENABLE_OVERLOADING)
data TrieRefMethodInfo
instance (signature ~ (m Trie), MonadIO m) => O.OverloadedMethod TrieRefMethodInfo Trie signature where
overloadedMethod = trieRef
instance O.OverloadedMethodInfo TrieRefMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieRef"
})
#endif
foreign import ccall "dzl_trie_remove" dzl_trie_remove ::
Ptr Trie ->
CString ->
IO CInt
trieRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> T.Text
-> m Bool
trieRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Trie -> Text -> m Bool
trieRemove Trie
trie Text
key = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
CString
key' <- Text -> IO CString
textToCString Text
key
CInt
result <- Ptr Trie -> CString -> IO CInt
dzl_trie_remove Ptr Trie
trie' CString
key'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TrieRemoveMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod TrieRemoveMethodInfo Trie signature where
overloadedMethod = trieRemove
instance O.OverloadedMethodInfo TrieRemoveMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieRemove"
})
#endif
foreign import ccall "dzl_trie_traverse" dzl_trie_traverse ::
Ptr Trie ->
CString ->
CUInt ->
CUInt ->
Int32 ->
FunPtr Dazzle.Callbacks.C_TrieTraverseFunc ->
Ptr () ->
IO ()
trieTraverse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> T.Text
-> GLib.Enums.TraverseType
-> [GLib.Flags.TraverseFlags]
-> Int32
-> Dazzle.Callbacks.TrieTraverseFunc
-> m ()
trieTraverse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Trie
-> Text
-> TraverseType
-> [TraverseFlags]
-> Int32
-> TrieTraverseFunc
-> m ()
trieTraverse Trie
trie Text
key TraverseType
order [TraverseFlags]
flags Int32
maxDepth TrieTraverseFunc
func = 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 Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
CString
key' <- Text -> IO CString
textToCString Text
key
let order' :: CUInt
order' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TraverseType -> Int) -> TraverseType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraverseType -> Int
forall a. Enum a => a -> Int
fromEnum) TraverseType
order
let flags' :: CUInt
flags' = [TraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TraverseFlags]
flags
FunPtr C_TrieTraverseFunc
func' <- C_TrieTraverseFunc -> IO (FunPtr C_TrieTraverseFunc)
Dazzle.Callbacks.mk_TrieTraverseFunc (Maybe (Ptr (FunPtr C_TrieTraverseFunc))
-> TrieTraverseFunc_WithClosures -> C_TrieTraverseFunc
Dazzle.Callbacks.wrap_TrieTraverseFunc Maybe (Ptr (FunPtr C_TrieTraverseFunc))
forall a. Maybe a
Nothing (TrieTraverseFunc -> TrieTraverseFunc_WithClosures
Dazzle.Callbacks.drop_closures_TrieTraverseFunc TrieTraverseFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Trie
-> CString
-> CUInt
-> CUInt
-> Int32
-> FunPtr C_TrieTraverseFunc
-> C_DestroyNotify
dzl_trie_traverse Ptr Trie
trie' CString
key' CUInt
order' CUInt
flags' Int32
maxDepth FunPtr C_TrieTraverseFunc
func' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_TrieTraverseFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TrieTraverseFunc
func'
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TrieTraverseMethodInfo
instance (signature ~ (T.Text -> GLib.Enums.TraverseType -> [GLib.Flags.TraverseFlags] -> Int32 -> Dazzle.Callbacks.TrieTraverseFunc -> m ()), MonadIO m) => O.OverloadedMethod TrieTraverseMethodInfo Trie signature where
overloadedMethod = trieTraverse
instance O.OverloadedMethodInfo TrieTraverseMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieTraverse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieTraverse"
})
#endif
foreign import ccall "dzl_trie_unref" dzl_trie_unref ::
Ptr Trie ->
IO ()
trieUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Trie
-> m ()
trieUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Trie -> m ()
trieUnref Trie
trie = 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 Trie
trie' <- Trie -> IO (Ptr Trie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Trie
trie
Ptr Trie -> IO ()
dzl_trie_unref Ptr Trie
trie'
Trie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Trie
trie
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TrieUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TrieUnrefMethodInfo Trie signature where
overloadedMethod = trieUnref
instance O.OverloadedMethodInfo TrieUnrefMethodInfo Trie where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Dazzle.Structs.Trie.trieUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-Trie.html#v:trieUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTrieMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTrieMethod "destroy" o = TrieDestroyMethodInfo
ResolveTrieMethod "insert" o = TrieInsertMethodInfo
ResolveTrieMethod "lookup" o = TrieLookupMethodInfo
ResolveTrieMethod "ref" o = TrieRefMethodInfo
ResolveTrieMethod "remove" o = TrieRemoveMethodInfo
ResolveTrieMethod "traverse" o = TrieTraverseMethodInfo
ResolveTrieMethod "unref" o = TrieUnrefMethodInfo
ResolveTrieMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTrieMethod t Trie, O.OverloadedMethod info Trie p) => OL.IsLabel t (Trie -> 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 ~ ResolveTrieMethod t Trie, O.OverloadedMethod info Trie p, R.HasField t Trie p) => R.HasField t Trie p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTrieMethod t Trie, O.OverloadedMethodInfo info Trie) => OL.IsLabel t (O.MethodProxy info Trie) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif