{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.OSTree.Structs.KernelArgs
    ( 

-- * Exported types
    KernelArgs(..)                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [append]("GI.OSTree.Structs.KernelArgs#g:method:append"), [appendArgv]("GI.OSTree.Structs.KernelArgs#g:method:appendArgv"), [appendArgvFiltered]("GI.OSTree.Structs.KernelArgs#g:method:appendArgvFiltered"), [appendIfMissing]("GI.OSTree.Structs.KernelArgs#g:method:appendIfMissing"), [appendProcCmdline]("GI.OSTree.Structs.KernelArgs#g:method:appendProcCmdline"), [contains]("GI.OSTree.Structs.KernelArgs#g:method:contains"), [delete]("GI.OSTree.Structs.KernelArgs#g:method:delete"), [deleteIfPresent]("GI.OSTree.Structs.KernelArgs#g:method:deleteIfPresent"), [deleteKeyEntry]("GI.OSTree.Structs.KernelArgs#g:method:deleteKeyEntry"), [free]("GI.OSTree.Structs.KernelArgs#g:method:free"), [newReplace]("GI.OSTree.Structs.KernelArgs#g:method:newReplace"), [parseAppend]("GI.OSTree.Structs.KernelArgs#g:method:parseAppend"), [replace]("GI.OSTree.Structs.KernelArgs#g:method:replace"), [replaceArgv]("GI.OSTree.Structs.KernelArgs#g:method:replaceArgv"), [replaceTake]("GI.OSTree.Structs.KernelArgs#g:method:replaceTake"), [toString]("GI.OSTree.Structs.KernelArgs#g:method:toString"), [toStrv]("GI.OSTree.Structs.KernelArgs#g:method:toStrv").
-- 
-- ==== Getters
-- [getLastValue]("GI.OSTree.Structs.KernelArgs#g:method:getLastValue").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveKernelArgsMethod                 ,
#endif

-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    KernelArgsAppendMethodInfo              ,
#endif
    kernelArgsAppend                        ,


-- ** appendArgv #method:appendArgv#

#if defined(ENABLE_OVERLOADING)
    KernelArgsAppendArgvMethodInfo          ,
#endif
    kernelArgsAppendArgv                    ,


-- ** appendArgvFiltered #method:appendArgvFiltered#

#if defined(ENABLE_OVERLOADING)
    KernelArgsAppendArgvFilteredMethodInfo  ,
#endif
    kernelArgsAppendArgvFiltered            ,


-- ** appendIfMissing #method:appendIfMissing#

#if defined(ENABLE_OVERLOADING)
    KernelArgsAppendIfMissingMethodInfo     ,
#endif
    kernelArgsAppendIfMissing               ,


-- ** appendProcCmdline #method:appendProcCmdline#

#if defined(ENABLE_OVERLOADING)
    KernelArgsAppendProcCmdlineMethodInfo   ,
#endif
    kernelArgsAppendProcCmdline             ,


-- ** cleanup #method:cleanup#

    kernelArgsCleanup                       ,


-- ** contains #method:contains#

#if defined(ENABLE_OVERLOADING)
    KernelArgsContainsMethodInfo            ,
#endif
    kernelArgsContains                      ,


-- ** delete #method:delete#

#if defined(ENABLE_OVERLOADING)
    KernelArgsDeleteMethodInfo              ,
#endif
    kernelArgsDelete                        ,


-- ** deleteIfPresent #method:deleteIfPresent#

#if defined(ENABLE_OVERLOADING)
    KernelArgsDeleteIfPresentMethodInfo     ,
#endif
    kernelArgsDeleteIfPresent               ,


-- ** deleteKeyEntry #method:deleteKeyEntry#

#if defined(ENABLE_OVERLOADING)
    KernelArgsDeleteKeyEntryMethodInfo      ,
#endif
    kernelArgsDeleteKeyEntry                ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    KernelArgsFreeMethodInfo                ,
#endif
    kernelArgsFree                          ,


-- ** getLastValue #method:getLastValue#

#if defined(ENABLE_OVERLOADING)
    KernelArgsGetLastValueMethodInfo        ,
#endif
    kernelArgsGetLastValue                  ,


-- ** newReplace #method:newReplace#

#if defined(ENABLE_OVERLOADING)
    KernelArgsNewReplaceMethodInfo          ,
#endif
    kernelArgsNewReplace                    ,


-- ** parseAppend #method:parseAppend#

#if defined(ENABLE_OVERLOADING)
    KernelArgsParseAppendMethodInfo         ,
#endif
    kernelArgsParseAppend                   ,


-- ** replace #method:replace#

#if defined(ENABLE_OVERLOADING)
    KernelArgsReplaceMethodInfo             ,
#endif
    kernelArgsReplace                       ,


-- ** replaceArgv #method:replaceArgv#

#if defined(ENABLE_OVERLOADING)
    KernelArgsReplaceArgvMethodInfo         ,
#endif
    kernelArgsReplaceArgv                   ,


-- ** replaceTake #method:replaceTake#

#if defined(ENABLE_OVERLOADING)
    KernelArgsReplaceTakeMethodInfo         ,
#endif
    kernelArgsReplaceTake                   ,


-- ** toString #method:toString#

#if defined(ENABLE_OVERLOADING)
    KernelArgsToStringMethodInfo            ,
#endif
    kernelArgsToString                      ,


-- ** toStrv #method:toStrv#

#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.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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

#else
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

#endif

-- | Memory-managed wrapper type.
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
$c== :: KernelArgs -> KernelArgs -> Bool
== :: KernelArgs -> KernelArgs -> Bool
$c/= :: KernelArgs -> KernelArgs -> Bool
/= :: KernelArgs -> KernelArgs -> Bool
Eq)

instance SP.ManagedPtrNewtype KernelArgs where
    toManagedPtr :: KernelArgs -> ManagedPtr KernelArgs
toManagedPtr (KernelArgs ManagedPtr KernelArgs
p) = ManagedPtr KernelArgs
p

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr KernelArgs where
    boxedPtrCopy :: KernelArgs -> IO KernelArgs
boxedPtrCopy = KernelArgs -> IO KernelArgs
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: KernelArgs -> IO ()
boxedPtrFree = \KernelArgs
_x -> () -> IO ()
forall a. a -> IO a
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, DK.Type)])
#endif

-- method KernelArgs::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair to be added"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_append" ostree_kernel_args_append :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    IO ()

-- | Appends /@arg@/ which is in the form of key=value pair to the hash table kargs->table
-- (appends to the value list if key is already in the hash table)
-- and appends key to kargs->order if it is not in the hash table already.
-- 
-- /Since: 2019.3/
kernelArgsAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair to be added
    -> m ()
kernelArgsAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsAppend KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    ostree_kernel_args_append kargs' arg'
    touchManagedPtr kargs
    freeMem arg'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppend"
        })


#endif

-- method KernelArgs::append_argv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , argCType = Just "char**"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of key=value argument pairs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_append_argv" ostree_kernel_args_append_argv :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

-- | Appends each value in /@argv@/ to the corresponding value array and
-- appends key to kargs->order if it is not in the hash table already.
-- 
-- /Since: 2019.3/
kernelArgsAppendArgv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> [T.Text]
    -- ^ /@argv@/: an array of key=value argument pairs
    -> m ()
kernelArgsAppendArgv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> [Text] -> m ()
kernelArgsAppendArgv KernelArgs
kargs [Text]
argv = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    argv' <- packZeroTerminatedUTF8CArray argv
    ostree_kernel_args_append_argv kargs' argv'
    touchManagedPtr kargs
    mapZeroTerminatedCArray freeMem argv'
    freeMem argv'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendArgv"
        })


#endif

-- method KernelArgs::append_argv_filtered
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , argCType = Just "char**"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of key=value argument pairs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prefixes"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , argCType = Just "char**"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of prefix strings"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_append_argv_filtered" ostree_kernel_args_append_argv_filtered :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr CString ->                          -- prefixes : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

-- | Appends each argument that does not have one of the /@prefixes@/ as prefix to the /@kargs@/
-- 
-- /Since: 2019.3/
kernelArgsAppendArgvFiltered ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> [T.Text]
    -- ^ /@argv@/: an array of key=value argument pairs
    -> [T.Text]
    -- ^ /@prefixes@/: an array of prefix strings
    -> m ()
kernelArgsAppendArgvFiltered :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> [Text] -> [Text] -> m ()
kernelArgsAppendArgvFiltered KernelArgs
kargs [Text]
argv [Text]
prefixes = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    argv' <- packZeroTerminatedUTF8CArray argv
    prefixes' <- packZeroTerminatedUTF8CArray prefixes
    ostree_kernel_args_append_argv_filtered kargs' argv' prefixes'
    touchManagedPtr kargs
    mapZeroTerminatedCArray freeMem argv'
    freeMem argv'
    mapZeroTerminatedCArray freeMem prefixes'
    freeMem prefixes'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendArgvFiltered"
        })


#endif

-- method KernelArgs::append_if_missing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair to be added"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_append_if_missing" ostree_kernel_args_append_if_missing :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    IO ()

-- | Appends /@arg@/ which is in the form of key=value pair to the hash table kargs->table
-- (appends to the value list if key is not in the hash table)
-- and appends key to kargs->order if it is not in the hash table.
-- 
-- /Since: 2022.5/
kernelArgsAppendIfMissing ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair to be added
    -> m ()
kernelArgsAppendIfMissing :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsAppendIfMissing KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    ostree_kernel_args_append_if_missing kargs' arg'
    touchManagedPtr kargs
    freeMem arg'
    return ()

#if defined(ENABLE_OVERLOADING)
data KernelArgsAppendIfMissingMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsAppendIfMissingMethodInfo KernelArgs signature where
    overloadedMethod = kernelArgsAppendIfMissing

instance O.OverloadedMethodInfo KernelArgsAppendIfMissingMethodInfo KernelArgs where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsAppendIfMissing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendIfMissing"
        })


#endif

-- method KernelArgs::append_proc_cmdline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , argCType = Just "GCancellable*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "optional GCancellable object, NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_kernel_args_append_proc_cmdline" ostree_kernel_args_append_proc_cmdline :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Appends the command line arguments in the file \"\/proc\/cmdline\"
-- that does not have \"BOOT_IMAGE=\" and \"initrd=\" as prefixes to the /@kargs@/
-- 
-- /Since: 2019.3/
kernelArgsAppendProcCmdline ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> Maybe (a)
    -- ^ /@cancellable@/: optional GCancellable object, NULL to ignore
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
kernelArgsAppendProcCmdline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
KernelArgs -> Maybe a -> m ()
kernelArgsAppendProcCmdline KernelArgs
kargs Maybe a
cancellable = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    maybeCancellable <- case cancellable of
        Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just a
jCancellable -> do
            jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_kernel_args_append_proc_cmdline kargs' maybeCancellable
        touchManagedPtr kargs
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsAppendProcCmdline"
        })


#endif

-- method KernelArgs::contains
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair to check"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_contains" ostree_kernel_args_contains :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    IO CInt

-- | Search for /@arg@/ which is in the form of key=value pair at the hash table kargs->table
-- and returns true if finds it.
-- 
-- /Since: 2022.7/
kernelArgsContains ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair to check
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@arg@/ is contained in /@kargs@/, 'P.False' otherwise.
kernelArgsContains :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m Bool
kernelArgsContains KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    result <- ostree_kernel_args_contains kargs' arg'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr kargs
    freeMem arg'
    return result'

#if defined(ENABLE_OVERLOADING)
data KernelArgsContainsMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod KernelArgsContainsMethodInfo KernelArgs signature where
    overloadedMethod = kernelArgsContains

instance O.OverloadedMethodInfo KernelArgsContainsMethodInfo KernelArgs where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsContains",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsContains"
        })


#endif

-- method KernelArgs::delete
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair for deletion"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_kernel_args_delete" ostree_kernel_args_delete :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | There are few scenarios being handled for deletion:
-- 
--  1: for input arg with a single key(i.e without = for split),
--  the key\/value pair will be deleted if there is only
--  one value that is associated with the key
-- 
--  2: for input arg wth key\/value pair, the specific key
--  value pair will be deleted from the pointer array
--  if those exist.
-- 
--  3: If the found key has only one value
--  associated with it, the key entry in the table will also
--  be removed, and the key will be removed from order table
-- 
--  Returns: 'P.True' on success, 'P.False' on failure
-- 
--  Since: 2019.3
kernelArgsDelete ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair for deletion
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
kernelArgsDelete :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsDelete KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    onException (do
        _ <- propagateGError $ ostree_kernel_args_delete kargs' arg'
        touchManagedPtr kargs
        freeMem arg'
        return ()
     ) (do
        freeMem 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsDelete"
        })


#endif

-- method KernelArgs::delete_if_present
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair to be deleted"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_kernel_args_delete_if_present" ostree_kernel_args_delete_if_present :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Deletes /@arg@/ which is in the form of key=value pair from the hash table kargs->table.
-- 
-- /Since: 2022.7/
kernelArgsDeleteIfPresent ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair to be deleted
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
kernelArgsDeleteIfPresent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsDeleteIfPresent KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    onException (do
        _ <- propagateGError $ ostree_kernel_args_delete_if_present kargs' arg'
        touchManagedPtr kargs
        freeMem arg'
        return ()
     ) (do
        freeMem arg'
     )

#if defined(ENABLE_OVERLOADING)
data KernelArgsDeleteIfPresentMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod KernelArgsDeleteIfPresentMethodInfo KernelArgs signature where
    overloadedMethod = kernelArgsDeleteIfPresent

instance O.OverloadedMethodInfo KernelArgsDeleteIfPresentMethodInfo KernelArgs where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.KernelArgs.kernelArgsDeleteIfPresent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsDeleteIfPresent"
        })


#endif

-- method KernelArgs::delete_key_entry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the key to remove" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_kernel_args_delete_key_entry" ostree_kernel_args_delete_key_entry :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- key : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function removes the key entry from the hashtable
-- as well from the order pointer array inside kargs
-- 
-- Note: since both table and order inside kernel args
-- are with free function, no extra free functions are
-- being called as they are done automatically by GLib
-- 
-- /Since: 2019.3/
kernelArgsDeleteKeyEntry ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: an OstreeKernelArgs instance
    -> T.Text
    -- ^ /@key@/: the key to remove
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
kernelArgsDeleteKeyEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsDeleteKeyEntry KernelArgs
kargs Text
key = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    key' <- textToCString key
    onException (do
        _ <- propagateGError $ ostree_kernel_args_delete_key_entry kargs' key'
        touchManagedPtr kargs
        freeMem key'
        return ()
     ) (do
        freeMem 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsDeleteKeyEntry"
        })


#endif

-- method KernelArgs::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "An OstreeKernelArgs that represents kernel arguments"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_free" ostree_kernel_args_free :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    IO ()

-- | Frees the kargs structure
-- 
-- /Since: 2019.3/
kernelArgsFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: An OstreeKernelArgs that represents kernel arguments
    -> m ()
kernelArgsFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m ()
kernelArgsFree KernelArgs
kargs = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    ostree_kernel_args_free kargs'
    touchManagedPtr kargs
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsFree"
        })


#endif

-- method KernelArgs::get_last_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key to look for in @kargs hash table"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_get_last_value" ostree_kernel_args_get_last_value :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- key : TBasicType TUTF8
    IO CString

-- | Finds and returns the last element of value array
-- corresponding to the /@key@/ in /@kargs@/ hash table. Note that the application
-- will be terminated if the /@key@/ is found but the value array is empty
-- 
-- /Since: 2019.3/
kernelArgsGetLastValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@key@/: a key to look for in /@kargs@/ hash table
    -> m (Maybe T.Text)
    -- ^ __Returns:__ 'P.Nothing' if /@key@/ is not found in the /@kargs@/ hash table,
    -- otherwise returns last element of value array corresponding to /@key@/
kernelArgsGetLastValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m (Maybe Text)
kernelArgsGetLastValue KernelArgs
kargs Text
key = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    key' <- textToCString key
    result <- ostree_kernel_args_get_last_value kargs' key'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        return result''
    touchManagedPtr kargs
    freeMem key'
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data KernelArgsGetLastValueMethodInfo
instance (signature ~ (T.Text -> m (Maybe 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsGetLastValue"
        })


#endif

-- method KernelArgs::new_replace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string argument" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_kernel_args_new_replace" ostree_kernel_args_new_replace :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function implements the basic logic behind key\/value pair
-- replacement. Do note that the arg need to be properly formatted
-- 
-- When replacing key with exact one value, the arg can be in
-- the form:
-- key, key=new_val, or key=old_val=new_val
-- The first one swaps the old_val with the key to an empty value
-- The second and third replace the old_val into the new_val
-- 
-- When replacing key with multiple values, the arg can only be
-- in the form of:
-- key=old_val=new_val. Unless there is a special case where
-- there is an empty value associated with the key, then
-- key=new_val will work because old_val is empty. The empty
-- val will be swapped with the new_val in that case
-- 
-- /Since: 2019.3/
kernelArgsNewReplace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: a string argument
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
kernelArgsNewReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsNewReplace KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    onException (do
        _ <- propagateGError $ ostree_kernel_args_new_replace kargs' arg'
        touchManagedPtr kargs
        freeMem arg'
        return ()
     ) (do
        freeMem 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsNewReplace"
        })


#endif

-- method KernelArgs::parse_append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string representing command line arguments"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_parse_append" ostree_kernel_args_parse_append :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- options : TBasicType TUTF8
    IO ()

-- | Parses /@options@/ by separating it by whitespaces and appends each argument to /@kargs@/
-- 
-- /Since: 2019.3/
kernelArgsParseAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@options@/: a string representing command line arguments
    -> m ()
kernelArgsParseAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsParseAppend KernelArgs
kargs Text
options = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    options' <- textToCString options
    ostree_kernel_args_parse_append kargs' options'
    touchManagedPtr kargs
    freeMem options'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsParseAppend"
        })


#endif

-- method KernelArgs::replace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair for replacement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_replace" ostree_kernel_args_replace :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    IO ()

-- | Finds and replaces the old key if /@arg@/ is already in the hash table,
-- otherwise adds /@arg@/ as new key and split_keyeq (arg) as value.
-- Note that when replacing old key value pair, the old values are freed.
-- 
-- /Since: 2019.3/
kernelArgsReplace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair for replacement
    -> m ()
kernelArgsReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplace KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    ostree_kernel_args_replace kargs' arg'
    touchManagedPtr kargs
    freeMem arg'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplace"
        })


#endif

-- method KernelArgs::replace_argv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "argv"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of key or key/value pairs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_replace_argv" ostree_kernel_args_replace_argv :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- argv : TBasicType TUTF8
    IO ()

-- | Finds and replaces each non-null arguments of /@argv@/ in the hash table,
-- otherwise adds individual arg as new key and split_keyeq (arg) as value.
-- Note that when replacing old key value pair, the old values are freed.
-- 
-- /Since: 2019.3/
kernelArgsReplaceArgv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@argv@/: an array of key or key\/value pairs
    -> m ()
kernelArgsReplaceArgv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplaceArgv KernelArgs
kargs Text
argv = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    argv' <- textToCString argv
    ostree_kernel_args_replace_argv kargs' argv'
    touchManagedPtr kargs
    freeMem argv'
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplaceArgv"
        })


#endif

-- method KernelArgs::replace_take
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key or key/value pair for replacement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_replace_take" ostree_kernel_args_replace_take :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    CString ->                              -- arg : TBasicType TUTF8
    IO ()

-- | Finds and replaces the old key if /@arg@/ is already in the hash table,
-- otherwise adds /@arg@/ as new key and split_keyeq (arg) as value.
-- Note that when replacing old key, the old values are freed.
-- 
-- /Since: 2019.3/
kernelArgsReplaceTake ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> T.Text
    -- ^ /@arg@/: key or key\/value pair for replacement
    -> m ()
kernelArgsReplaceTake :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> Text -> m ()
kernelArgsReplaceTake KernelArgs
kargs Text
arg = 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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    arg' <- textToCString arg
    ostree_kernel_args_replace_take kargs' arg'
    touchManagedPtr kargs
    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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsReplaceTake"
        })


#endif

-- method KernelArgs::to_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_to_string" ostree_kernel_args_to_string :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    IO CString

-- | Extracts all key value pairs in /@kargs@/ and appends to a temporary
-- GString in forms of \"key=value\" or \"key\" if value is NULL separated
-- by a single whitespace, and returns the temporary string with the
-- GString wrapper freed
-- 
-- Note: the application will be terminated if one of the values array
-- in /@kargs@/ is NULL
-- 
-- /Since: 2019.3/
kernelArgsToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> m T.Text
    -- ^ __Returns:__ a string of \"key=value\" pairs or \"key\" if value is NULL,
    -- separated by single whitespaces
kernelArgsToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m Text
kernelArgsToString KernelArgs
kargs = IO Text -> m Text
forall a. IO a -> m a
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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    result <- ostree_kernel_args_to_string kargs'
    checkUnexpectedReturnNULL "kernelArgsToString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr kargs
    return 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsToString"
        })


#endif

-- method KernelArgs::to_strv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "kargs"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "KernelArgs" }
--           , argCType = Just "OstreeKernelArgs*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a OstreeKernelArgs instance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_to_strv" ostree_kernel_args_to_strv :: 
    Ptr KernelArgs ->                       -- kargs : TInterface (Name {namespace = "OSTree", name = "KernelArgs"})
    IO (Ptr CString)

-- | Extracts all key value pairs in /@kargs@/ and appends to a temporary
-- array in forms of \"key=value\" or \"key\" if value is NULL, and returns
-- the temporary array with the GPtrArray wrapper freed
-- 
-- /Since: 2019.3/
kernelArgsToStrv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    KernelArgs
    -- ^ /@kargs@/: a OstreeKernelArgs instance
    -> m [T.Text]
    -- ^ __Returns:__ an array of \"key=value\" pairs or \"key\" if value is NULL
kernelArgsToStrv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
KernelArgs -> m [Text]
kernelArgsToStrv KernelArgs
kargs = IO [Text] -> m [Text]
forall a. IO a -> m a
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
    kargs' <- KernelArgs -> IO (Ptr KernelArgs)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KernelArgs
kargs
    result <- ostree_kernel_args_to_strv kargs'
    checkUnexpectedReturnNULL "kernelArgsToStrv" result
    result' <- unpackZeroTerminatedUTF8CArray result
    mapZeroTerminatedCArray freeMem result
    freeMem result
    touchManagedPtr kargs
    return 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.19/docs/GI-OSTree-Structs-KernelArgs.html#v:kernelArgsToStrv"
        })


#endif

-- method KernelArgs::cleanup
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "loc"
--           , argType = TBasicType TPtr
--           , argCType = Just "void*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Address of an OstreeKernelArgs pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_kernel_args_cleanup" ostree_kernel_args_cleanup :: 
    Ptr () ->                               -- loc : TBasicType TPtr
    IO ()

-- | Frees the OstreeKernelArgs structure pointed by *loc
-- 
-- /Since: 2019.3/
kernelArgsCleanup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@loc@/: Address of an OstreeKernelArgs pointer
    -> m ()
kernelArgsCleanup :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
kernelArgsCleanup Ptr ()
loc = 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 () -> IO ()
ostree_kernel_args_cleanup Ptr ()
loc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveKernelArgsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveKernelArgsMethod "append" o = KernelArgsAppendMethodInfo
    ResolveKernelArgsMethod "appendArgv" o = KernelArgsAppendArgvMethodInfo
    ResolveKernelArgsMethod "appendArgvFiltered" o = KernelArgsAppendArgvFilteredMethodInfo
    ResolveKernelArgsMethod "appendIfMissing" o = KernelArgsAppendIfMissingMethodInfo
    ResolveKernelArgsMethod "appendProcCmdline" o = KernelArgsAppendProcCmdlineMethodInfo
    ResolveKernelArgsMethod "contains" o = KernelArgsContainsMethodInfo
    ResolveKernelArgsMethod "delete" o = KernelArgsDeleteMethodInfo
    ResolveKernelArgsMethod "deleteIfPresent" o = KernelArgsDeleteIfPresentMethodInfo
    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