{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Structs.KernelArgs
(
KernelArgs(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveKernelArgsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
KernelArgsAppendMethodInfo ,
#endif
kernelArgsAppend ,
#if defined(ENABLE_OVERLOADING)
KernelArgsAppendArgvMethodInfo ,
#endif
kernelArgsAppendArgv ,
#if defined(ENABLE_OVERLOADING)
KernelArgsAppendArgvFilteredMethodInfo ,
#endif
kernelArgsAppendArgvFiltered ,
#if defined(ENABLE_OVERLOADING)
KernelArgsAppendProcCmdlineMethodInfo ,
#endif
kernelArgsAppendProcCmdline ,
kernelArgsCleanup ,
#if defined(ENABLE_OVERLOADING)
KernelArgsDeleteMethodInfo ,
#endif
kernelArgsDelete ,
#if defined(ENABLE_OVERLOADING)
KernelArgsDeleteKeyEntryMethodInfo ,
#endif
kernelArgsDeleteKeyEntry ,
#if defined(ENABLE_OVERLOADING)
KernelArgsFreeMethodInfo ,
#endif
kernelArgsFree ,
#if defined(ENABLE_OVERLOADING)
KernelArgsGetLastValueMethodInfo ,
#endif
kernelArgsGetLastValue ,
#if defined(ENABLE_OVERLOADING)
KernelArgsNewReplaceMethodInfo ,
#endif
kernelArgsNewReplace ,
#if defined(ENABLE_OVERLOADING)
KernelArgsParseAppendMethodInfo ,
#endif
kernelArgsParseAppend ,
#if defined(ENABLE_OVERLOADING)
KernelArgsReplaceMethodInfo ,
#endif
kernelArgsReplace ,
#if defined(ENABLE_OVERLOADING)
KernelArgsReplaceArgvMethodInfo ,
#endif
kernelArgsReplaceArgv ,
#if defined(ENABLE_OVERLOADING)
KernelArgsReplaceTakeMethodInfo ,
#endif
kernelArgsReplaceTake ,
#if defined(ENABLE_OVERLOADING)
KernelArgsToStringMethodInfo ,
#endif
kernelArgsToString ,
#if defined(ENABLE_OVERLOADING)
KernelArgsToStrvMethodInfo ,
#endif
kernelArgsToStrv ,
) 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.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.Gio.Objects.Cancellable as Gio.Cancellable
newtype KernelArgs = KernelArgs (SP.ManagedPtr KernelArgs)
deriving (KernelArgs -> KernelArgs -> Bool
(KernelArgs -> KernelArgs -> Bool)
-> (KernelArgs -> KernelArgs -> Bool) -> Eq KernelArgs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KernelArgs -> KernelArgs -> Bool
$c/= :: KernelArgs -> KernelArgs -> Bool
== :: KernelArgs -> KernelArgs -> Bool
$c== :: KernelArgs -> KernelArgs -> Bool
Eq)
instance SP.ManagedPtrNewtype KernelArgs where
toManagedPtr :: KernelArgs -> ManagedPtr KernelArgs
toManagedPtr (KernelArgs ManagedPtr KernelArgs
p) = ManagedPtr KernelArgs
p
instance BoxedPtr KernelArgs where
boxedPtrCopy :: KernelArgs -> IO KernelArgs
boxedPtrCopy = KernelArgs -> IO KernelArgs
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: KernelArgs -> IO ()
boxedPtrFree = \KernelArgs
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList KernelArgs
type instance O.AttributeList KernelArgs = KernelArgsAttributeList
type KernelArgsAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "ostree_kernel_args_append" ostree_kernel_args_append ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsAppend KernelArgs
kargs Text
arg = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
arg' <- Text -> IO CString
textToCString Text
arg
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_append Ptr KernelArgs
kargs' CString
arg'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsAppendMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsAppendMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsAppend
instance O.OverloadedMethodInfo KernelArgsAppendMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppend"
})
#endif
foreign import ccall "ostree_kernel_args_append_argv" ostree_kernel_args_append_argv ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsAppendArgv ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsAppendArgv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsAppendArgv KernelArgs
kargs Text
argv = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
argv' <- Text -> IO CString
textToCString Text
argv
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_append_argv Ptr KernelArgs
kargs' CString
argv'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
argv'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsAppendArgvMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsAppendArgvMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsAppendArgv
instance O.OverloadedMethodInfo KernelArgsAppendArgvMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsAppendArgv",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendArgv"
})
#endif
foreign import ccall "ostree_kernel_args_append_argv_filtered" ostree_kernel_args_append_argv_filtered ::
Ptr KernelArgs ->
CString ->
CString ->
IO ()
kernelArgsAppendArgvFiltered ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> T.Text
-> m ()
kernelArgsAppendArgvFiltered :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> Text -> m ()
kernelArgsAppendArgvFiltered KernelArgs
kargs Text
argv Text
prefixes = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
argv' <- Text -> IO CString
textToCString Text
argv
CString
prefixes' <- Text -> IO CString
textToCString Text
prefixes
Ptr KernelArgs -> CString -> CString -> IO ()
ostree_kernel_args_append_argv_filtered Ptr KernelArgs
kargs' CString
argv' CString
prefixes'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
argv'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prefixes'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsAppendArgvFilteredMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsAppendArgvFilteredMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsAppendArgvFiltered
instance O.OverloadedMethodInfo KernelArgsAppendArgvFilteredMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsAppendArgvFiltered",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendArgvFiltered"
})
#endif
foreign import ccall "ostree_kernel_args_append_proc_cmdline" ostree_kernel_args_append_proc_cmdline ::
Ptr KernelArgs ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
kernelArgsAppendProcCmdline ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
KernelArgs
-> Maybe (a)
-> m ()
kernelArgsAppendProcCmdline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
KernelArgs -> Maybe a -> m ()
kernelArgsAppendProcCmdline KernelArgs
kargs Maybe a
cancellable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr KernelArgs -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_kernel_args_append_proc_cmdline Ptr KernelArgs
kargs' Ptr Cancellable
maybeCancellable
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data KernelArgsAppendProcCmdlineMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Gio.Cancellable.IsCancellable a) => O.OverloadedMethod KernelArgsAppendProcCmdlineMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsAppendProcCmdline
instance O.OverloadedMethodInfo KernelArgsAppendProcCmdlineMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsAppendProcCmdline",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendProcCmdline"
})
#endif
foreign import ccall "ostree_kernel_args_delete" ostree_kernel_args_delete ::
Ptr KernelArgs ->
CString ->
Ptr (Ptr GError) ->
IO CInt
kernelArgsDelete ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsDelete :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsDelete KernelArgs
kargs Text
arg = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
arg' <- Text -> IO CString
textToCString Text
arg
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr KernelArgs -> CString -> Ptr (Ptr GError) -> IO CInt
ostree_kernel_args_delete Ptr KernelArgs
kargs' CString
arg'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
)
#if defined(ENABLE_OVERLOADING)
data KernelArgsDeleteMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsDeleteMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsDelete
instance O.OverloadedMethodInfo KernelArgsDeleteMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsDelete",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsDelete"
})
#endif
foreign import ccall "ostree_kernel_args_delete_key_entry" ostree_kernel_args_delete_key_entry ::
Ptr KernelArgs ->
CString ->
Ptr (Ptr GError) ->
IO CInt
kernelArgsDeleteKeyEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsDeleteKeyEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsDeleteKeyEntry KernelArgs
kargs Text
key = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
key' <- Text -> IO CString
textToCString Text
key
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr KernelArgs -> CString -> Ptr (Ptr GError) -> IO CInt
ostree_kernel_args_delete_key_entry Ptr KernelArgs
kargs' CString
key'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
)
#if defined(ENABLE_OVERLOADING)
data KernelArgsDeleteKeyEntryMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsDeleteKeyEntryMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsDeleteKeyEntry
instance O.OverloadedMethodInfo KernelArgsDeleteKeyEntryMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsDeleteKeyEntry",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsDeleteKeyEntry"
})
#endif
foreign import ccall "ostree_kernel_args_free" ostree_kernel_args_free ::
Ptr KernelArgs ->
IO ()
kernelArgsFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> m ()
kernelArgsFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m ()
kernelArgsFree KernelArgs
kargs = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
Ptr KernelArgs -> IO ()
ostree_kernel_args_free Ptr KernelArgs
kargs'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod KernelArgsFreeMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsFree
instance O.OverloadedMethodInfo KernelArgsFreeMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsFree"
})
#endif
foreign import ccall "ostree_kernel_args_get_last_value" ostree_kernel_args_get_last_value ::
Ptr KernelArgs ->
CString ->
IO CString
kernelArgsGetLastValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m T.Text
kernelArgsGetLastValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m Text
kernelArgsGetLastValue KernelArgs
kargs Text
key = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
key' <- Text -> IO CString
textToCString Text
key
CString
result <- Ptr KernelArgs -> CString -> IO CString
ostree_kernel_args_get_last_value Ptr KernelArgs
kargs' CString
key'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"kernelArgsGetLastValue" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data KernelArgsGetLastValueMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.OverloadedMethod KernelArgsGetLastValueMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsGetLastValue
instance O.OverloadedMethodInfo KernelArgsGetLastValueMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsGetLastValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsGetLastValue"
})
#endif
foreign import ccall "ostree_kernel_args_new_replace" ostree_kernel_args_new_replace ::
Ptr KernelArgs ->
CString ->
Ptr (Ptr GError) ->
IO CInt
kernelArgsNewReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsNewReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsNewReplace KernelArgs
kargs Text
arg = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
arg' <- Text -> IO CString
textToCString Text
arg
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr KernelArgs -> CString -> Ptr (Ptr GError) -> IO CInt
ostree_kernel_args_new_replace Ptr KernelArgs
kargs' CString
arg'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
)
#if defined(ENABLE_OVERLOADING)
data KernelArgsNewReplaceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsNewReplaceMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsNewReplace
instance O.OverloadedMethodInfo KernelArgsNewReplaceMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsNewReplace",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsNewReplace"
})
#endif
foreign import ccall "ostree_kernel_args_parse_append" ostree_kernel_args_parse_append ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsParseAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsParseAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsParseAppend KernelArgs
kargs Text
options = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
options' <- Text -> IO CString
textToCString Text
options
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_parse_append Ptr KernelArgs
kargs' CString
options'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
options'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsParseAppendMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsParseAppendMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsParseAppend
instance O.OverloadedMethodInfo KernelArgsParseAppendMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsParseAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsParseAppend"
})
#endif
foreign import ccall "ostree_kernel_args_replace" ostree_kernel_args_replace ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplace KernelArgs
kargs Text
arg = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
arg' <- Text -> IO CString
textToCString Text
arg
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_replace Ptr KernelArgs
kargs' CString
arg'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
arg'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsReplaceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsReplaceMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsReplace
instance O.OverloadedMethodInfo KernelArgsReplaceMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsReplace",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplace"
})
#endif
foreign import ccall "ostree_kernel_args_replace_argv" ostree_kernel_args_replace_argv ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsReplaceArgv ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsReplaceArgv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplaceArgv KernelArgs
kargs Text
argv = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
argv' <- Text -> IO CString
textToCString Text
argv
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_replace_argv Ptr KernelArgs
kargs' CString
argv'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
argv'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsReplaceArgvMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsReplaceArgvMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsReplaceArgv
instance O.OverloadedMethodInfo KernelArgsReplaceArgvMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsReplaceArgv",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplaceArgv"
})
#endif
foreign import ccall "ostree_kernel_args_replace_take" ostree_kernel_args_replace_take ::
Ptr KernelArgs ->
CString ->
IO ()
kernelArgsReplaceTake ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> T.Text
-> m ()
kernelArgsReplaceTake :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplaceTake KernelArgs
kargs Text
arg = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
arg' <- Text -> IO CString
textToCString Text
arg
Ptr KernelArgs -> CString -> IO ()
ostree_kernel_args_replace_take Ptr KernelArgs
kargs' CString
arg'
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data KernelArgsReplaceTakeMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsReplaceTakeMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsReplaceTake
instance O.OverloadedMethodInfo KernelArgsReplaceTakeMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsReplaceTake",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplaceTake"
})
#endif
foreign import ccall "ostree_kernel_args_to_string" ostree_kernel_args_to_string ::
Ptr KernelArgs ->
IO CString
kernelArgsToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> m T.Text
kernelArgsToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m Text
kernelArgsToString KernelArgs
kargs = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
CString
result <- Ptr KernelArgs -> IO CString
ostree_kernel_args_to_string Ptr KernelArgs
kargs'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"kernelArgsToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data KernelArgsToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod KernelArgsToStringMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsToString
instance O.OverloadedMethodInfo KernelArgsToStringMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsToString"
})
#endif
foreign import ccall "ostree_kernel_args_to_strv" ostree_kernel_args_to_strv ::
Ptr KernelArgs ->
IO (Ptr CString)
kernelArgsToStrv ::
(B.CallStack.HasCallStack, MonadIO m) =>
KernelArgs
-> m [T.Text]
kernelArgsToStrv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m [Text]
kernelArgsToStrv KernelArgs
kargs = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr KernelArgs
kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
Ptr CString
result <- Ptr KernelArgs -> IO (Ptr CString)
ostree_kernel_args_to_strv Ptr KernelArgs
kargs'
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"kernelArgsToStrv" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
KernelArgs -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KernelArgs
kargs
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data KernelArgsToStrvMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.OverloadedMethod KernelArgsToStrvMethodInfo KernelArgs signature where
overloadedMethod = kernelArgsToStrv
instance O.OverloadedMethodInfo KernelArgsToStrvMethodInfo KernelArgs where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsToStrv",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.15/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsToStrv"
})
#endif
foreign import ccall "ostree_kernel_args_cleanup" ostree_kernel_args_cleanup ::
Ptr () ->
IO ()
kernelArgsCleanup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m ()
kernelArgsCleanup :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
kernelArgsCleanup Ptr ()
loc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr () -> IO ()
ostree_kernel_args_cleanup Ptr ()
loc
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveKernelArgsMethod (t :: Symbol) (o :: *) :: * where
ResolveKernelArgsMethod "append" o = KernelArgsAppendMethodInfo
ResolveKernelArgsMethod "appendArgv" o = KernelArgsAppendArgvMethodInfo
ResolveKernelArgsMethod "appendArgvFiltered" o = KernelArgsAppendArgvFilteredMethodInfo
ResolveKernelArgsMethod "appendProcCmdline" o = KernelArgsAppendProcCmdlineMethodInfo
ResolveKernelArgsMethod "delete" o = KernelArgsDeleteMethodInfo
ResolveKernelArgsMethod "deleteKeyEntry" o = KernelArgsDeleteKeyEntryMethodInfo
ResolveKernelArgsMethod "free" o = KernelArgsFreeMethodInfo
ResolveKernelArgsMethod "newReplace" o = KernelArgsNewReplaceMethodInfo
ResolveKernelArgsMethod "parseAppend" o = KernelArgsParseAppendMethodInfo
ResolveKernelArgsMethod "replace" o = KernelArgsReplaceMethodInfo
ResolveKernelArgsMethod "replaceArgv" o = KernelArgsReplaceArgvMethodInfo
ResolveKernelArgsMethod "replaceTake" o = KernelArgsReplaceTakeMethodInfo
ResolveKernelArgsMethod "toString" o = KernelArgsToStringMethodInfo
ResolveKernelArgsMethod "toStrv" o = KernelArgsToStrvMethodInfo
ResolveKernelArgsMethod "getLastValue" o = KernelArgsGetLastValueMethodInfo
ResolveKernelArgsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveKernelArgsMethod t KernelArgs, O.OverloadedMethod info KernelArgs p) => OL.IsLabel t (KernelArgs -> 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 ~ ResolveKernelArgsMethod t KernelArgs, O.OverloadedMethod info KernelArgs p, R.HasField t KernelArgs p) => R.HasField t KernelArgs p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveKernelArgsMethod t KernelArgs, O.OverloadedMethodInfo info KernelArgs) => OL.IsLabel t (O.MethodProxy info KernelArgs) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif