diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 1.0.8 + ++ Update to haskell-gi(-base) 0.22 + +### 1.0.7 + ++ Update stack version to 12.10 + ### 1.0.6 + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading). diff --git a/GI/OSTree.hs b/GI/OSTree.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree.hs @@ -0,0 +1,60 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree + ( module GI.OSTree.Callbacks , + module GI.OSTree.Constants , + module GI.OSTree.Enums , + module GI.OSTree.Flags , + module GI.OSTree.Functions , + module GI.OSTree.Interfaces , + module GI.OSTree.Objects , + module GI.OSTree.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.OSTree.Callbacks +import GI.OSTree.Constants +import GI.OSTree.Enums +import GI.OSTree.Flags +import GI.OSTree.Functions +import GI.OSTree.Interfaces +import GI.OSTree.Objects +import GI.OSTree.Structs + +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.ManagedPtr as B.ManagedPtr +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.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 Data.GI.Base + diff --git a/GI/OSTree/Callbacks.hs b/GI/OSTree/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Callbacks.hs @@ -0,0 +1,1266 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Callbacks + ( + + -- * Signals +-- ** BootloaderInterfaceGetNameFieldCallback #signal:BootloaderInterfaceGetNameFieldCallback# + + BootloaderInterfaceGetNameFieldCallback , + C_BootloaderInterfaceGetNameFieldCallback, + dynamic_BootloaderInterfaceGetNameFieldCallback, + genClosure_BootloaderInterfaceGetNameFieldCallback, + mk_BootloaderInterfaceGetNameFieldCallback, + noBootloaderInterfaceGetNameFieldCallback, + wrap_BootloaderInterfaceGetNameFieldCallback, + + +-- ** BootloaderInterfaceIsAtomicFieldCallback #signal:BootloaderInterfaceIsAtomicFieldCallback# + + BootloaderInterfaceIsAtomicFieldCallback, + C_BootloaderInterfaceIsAtomicFieldCallback, + dynamic_BootloaderInterfaceIsAtomicFieldCallback, + genClosure_BootloaderInterfaceIsAtomicFieldCallback, + mk_BootloaderInterfaceIsAtomicFieldCallback, + noBootloaderInterfaceIsAtomicFieldCallback, + wrap_BootloaderInterfaceIsAtomicFieldCallback, + + +-- ** BootloaderInterfaceQueryFieldCallback #signal:BootloaderInterfaceQueryFieldCallback# + + BootloaderInterfaceQueryFieldCallback , + C_BootloaderInterfaceQueryFieldCallback , + dynamic_BootloaderInterfaceQueryFieldCallback, + mk_BootloaderInterfaceQueryFieldCallback, + noBootloaderInterfaceQueryFieldCallback , + + +-- ** CmdPrivateVTableOstreeFinalizeStagedFieldCallback #signal:CmdPrivateVTableOstreeFinalizeStagedFieldCallback# + + C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback, + CmdPrivateVTableOstreeFinalizeStagedFieldCallback, + dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback, + mk_CmdPrivateVTableOstreeFinalizeStagedFieldCallback, + noCmdPrivateVTableOstreeFinalizeStagedFieldCallback, + + +-- ** CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback #signal:CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback# + + C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback, + CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback, + dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback, + mk_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback, + noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback, + + +-- ** CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback #signal:CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback# + + C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback, + CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback, + dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback, + mk_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback, + noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback, + + +-- ** CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback# + + C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback, + CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback, + dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback, + mk_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback, + noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback, + + +-- ** CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback# + + C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback, + CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback, + dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback, + mk_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback, + noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback, + + +-- ** CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback# + + C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback, + CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback, + dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback, + mk_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback, + noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback, + + +-- ** CmdPrivateVTableOstreeSystemGeneratorFieldCallback #signal:CmdPrivateVTableOstreeSystemGeneratorFieldCallback# + + C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback, + CmdPrivateVTableOstreeSystemGeneratorFieldCallback, + dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback, + mk_CmdPrivateVTableOstreeSystemGeneratorFieldCallback, + noCmdPrivateVTableOstreeSystemGeneratorFieldCallback, + + +-- ** RepoCheckoutFilter #signal:RepoCheckoutFilter# + + C_RepoCheckoutFilter , + RepoCheckoutFilter , + RepoCheckoutFilter_WithClosures , + drop_closures_RepoCheckoutFilter , + dynamic_RepoCheckoutFilter , + genClosure_RepoCheckoutFilter , + mk_RepoCheckoutFilter , + noRepoCheckoutFilter , + noRepoCheckoutFilter_WithClosures , + wrap_RepoCheckoutFilter , + + +-- ** RepoCommitFilter #signal:RepoCommitFilter# + + C_RepoCommitFilter , + RepoCommitFilter , + RepoCommitFilter_WithClosures , + drop_closures_RepoCommitFilter , + dynamic_RepoCommitFilter , + genClosure_RepoCommitFilter , + mk_RepoCommitFilter , + noRepoCommitFilter , + noRepoCommitFilter_WithClosures , + wrap_RepoCommitFilter , + + +-- ** RepoCommitModifierXattrCallback #signal:RepoCommitModifierXattrCallback# + + C_RepoCommitModifierXattrCallback , + RepoCommitModifierXattrCallback , + RepoCommitModifierXattrCallback_WithClosures, + drop_closures_RepoCommitModifierXattrCallback, + dynamic_RepoCommitModifierXattrCallback , + genClosure_RepoCommitModifierXattrCallback, + mk_RepoCommitModifierXattrCallback , + noRepoCommitModifierXattrCallback , + noRepoCommitModifierXattrCallback_WithClosures, + wrap_RepoCommitModifierXattrCallback , + + +-- ** RepoImportArchiveTranslatePathname #signal:RepoImportArchiveTranslatePathname# + + C_RepoImportArchiveTranslatePathname , + RepoImportArchiveTranslatePathname , + RepoImportArchiveTranslatePathname_WithClosures, + drop_closures_RepoImportArchiveTranslatePathname, + dynamic_RepoImportArchiveTranslatePathname, + genClosure_RepoImportArchiveTranslatePathname, + mk_RepoImportArchiveTranslatePathname , + noRepoImportArchiveTranslatePathname , + noRepoImportArchiveTranslatePathname_WithClosures, + wrap_RepoImportArchiveTranslatePathname , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo +import {-# SOURCE #-} qualified GI.OSTree.Objects.Sysroot as OSTree.Sysroot +import {-# SOURCE #-} qualified GI.OSTree.Structs.Bootloader as OSTree.Bootloader + +-- callback RepoImportArchiveTranslatePathname +-- -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Stat buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path in the archive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Possibly change a pathname while importing an archive. If %NULL is returned,\nthen @src_path will be used unchanged. Otherwise, return a new pathname which\nwill be freed via `g_free()`.\n\nThis pathname translation will be performed *before* any processing from an\nactive `OstreeRepoCommitModifier`. Will be invoked for all directory and file\ntypes, first with outer directories, then their sub-files and directories.\n\nNote that enabling pathname translation will always override the setting for\n`use_ostree_convention`.", sinceVersion = Just "2017.11"}} +-- | Type for the callback on the (unwrapped) C side. +type C_RepoImportArchiveTranslatePathname = + Ptr OSTree.Repo.Repo -> + Ptr () -> + CString -> + Ptr () -> + IO CString + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Stat buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path in the archive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RepoImportArchiveTranslatePathname :: FunPtr C_RepoImportArchiveTranslatePathname -> C_RepoImportArchiveTranslatePathname + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RepoImportArchiveTranslatePathname :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + FunPtr C_RepoImportArchiveTranslatePathname + -> a + {- ^ /@repo@/: Repo -} + -> Ptr () + {- ^ /@stbuf@/: Stat buffer -} + -> T.Text + {- ^ /@srcPath@/: Path in the archive -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> m T.Text +dynamic_RepoImportArchiveTranslatePathname __funPtr repo stbuf srcPath userData = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + srcPath' <- textToCString srcPath + result <- (__dynamic_C_RepoImportArchiveTranslatePathname __funPtr) repo' stbuf srcPath' userData + checkUnexpectedReturnNULL "repoImportArchiveTranslatePathname" result + result' <- cstringToText result + freeMem result + touchManagedPtr repo + freeMem srcPath' + return result' + +-- | Generate a function pointer callable from C code, from a `C_RepoImportArchiveTranslatePathname`. +foreign import ccall "wrapper" + mk_RepoImportArchiveTranslatePathname :: C_RepoImportArchiveTranslatePathname -> IO (FunPtr C_RepoImportArchiveTranslatePathname) + +{- | +Possibly change a pathname while importing an archive. If 'Nothing' is returned, +then /@srcPath@/ will be used unchanged. Otherwise, return a new pathname which +will be freed via @g_free()@. + +This pathname translation will be performed *before* any processing from an +active @OstreeRepoCommitModifier@. Will be invoked for all directory and file +types, first with outer directories, then their sub-files and directories. + +Note that enabling pathname translation will always override the setting for +@use_ostree_convention@. + +/Since: 2017.11/ +-} +type RepoImportArchiveTranslatePathname = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> Ptr () + {- ^ /@stbuf@/: Stat buffer -} + -> T.Text + {- ^ /@srcPath@/: Path in the archive -} + -> IO T.Text + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname`@. +noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname +noRepoImportArchiveTranslatePathname = Nothing + +{- | +Possibly change a pathname while importing an archive. If 'Nothing' is returned, +then /@srcPath@/ will be used unchanged. Otherwise, return a new pathname which +will be freed via @g_free()@. + +This pathname translation will be performed *before* any processing from an +active @OstreeRepoCommitModifier@. Will be invoked for all directory and file +types, first with outer directories, then their sub-files and directories. + +Note that enabling pathname translation will always override the setting for +@use_ostree_convention@. + +/Since: 2017.11/ +-} +type RepoImportArchiveTranslatePathname_WithClosures = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> Ptr () + {- ^ /@stbuf@/: Stat buffer -} + -> T.Text + {- ^ /@srcPath@/: Path in the archive -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> IO T.Text + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname_WithClosures`@. +noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures +noRepoImportArchiveTranslatePathname_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname -> RepoImportArchiveTranslatePathname_WithClosures +drop_closures_RepoImportArchiveTranslatePathname _f repo stbuf srcPath _ = _f repo stbuf srcPath + +-- | Wrap the callback into a `GClosure`. +genClosure_RepoImportArchiveTranslatePathname :: MonadIO m => RepoImportArchiveTranslatePathname -> m (GClosure C_RepoImportArchiveTranslatePathname) +genClosure_RepoImportArchiveTranslatePathname cb = liftIO $ do + let cb' = drop_closures_RepoImportArchiveTranslatePathname cb + let cb'' = wrap_RepoImportArchiveTranslatePathname Nothing cb' + mk_RepoImportArchiveTranslatePathname cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `RepoImportArchiveTranslatePathname` into a `C_RepoImportArchiveTranslatePathname`. +wrap_RepoImportArchiveTranslatePathname :: + Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname)) -> + RepoImportArchiveTranslatePathname_WithClosures -> + C_RepoImportArchiveTranslatePathname +wrap_RepoImportArchiveTranslatePathname funptrptr _cb repo stbuf srcPath userData = do + repo' <- (newObject OSTree.Repo.Repo) repo + srcPath' <- cstringToText srcPath + result <- _cb repo' stbuf srcPath' userData + maybeReleaseFunPtr funptrptr + result' <- textToCString result + return result' + + +-- callback RepoCommitModifierXattrCallback +-- -> Callable {returnType = Just TVariant, returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_RepoCommitModifierXattrCallback = + Ptr OSTree.Repo.Repo -> + CString -> + Ptr Gio.FileInfo.FileInfo -> + Ptr () -> + IO (Ptr GVariant) + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RepoCommitModifierXattrCallback :: FunPtr C_RepoCommitModifierXattrCallback -> C_RepoCommitModifierXattrCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RepoCommitModifierXattrCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) => + FunPtr C_RepoCommitModifierXattrCallback + -> a + -> T.Text + -> b + -> Ptr () + -> m GVariant +dynamic_RepoCommitModifierXattrCallback __funPtr repo path fileInfo userData = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + path' <- textToCString path + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + result <- (__dynamic_C_RepoCommitModifierXattrCallback __funPtr) repo' path' fileInfo' userData + checkUnexpectedReturnNULL "repoCommitModifierXattrCallback" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr repo + touchManagedPtr fileInfo + freeMem path' + return result' + +-- | Generate a function pointer callable from C code, from a `C_RepoCommitModifierXattrCallback`. +foreign import ccall "wrapper" + mk_RepoCommitModifierXattrCallback :: C_RepoCommitModifierXattrCallback -> IO (FunPtr C_RepoCommitModifierXattrCallback) + +{- | +/No description available in the introspection data./ +-} +type RepoCommitModifierXattrCallback = + OSTree.Repo.Repo + -> T.Text + -> Gio.FileInfo.FileInfo + -> IO GVariant + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback`@. +noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback +noRepoCommitModifierXattrCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type RepoCommitModifierXattrCallback_WithClosures = + OSTree.Repo.Repo + -> T.Text + -> Gio.FileInfo.FileInfo + -> Ptr () + -> IO GVariant + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback_WithClosures`@. +noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures +noRepoCommitModifierXattrCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback -> RepoCommitModifierXattrCallback_WithClosures +drop_closures_RepoCommitModifierXattrCallback _f repo path fileInfo _ = _f repo path fileInfo + +-- | Wrap the callback into a `GClosure`. +genClosure_RepoCommitModifierXattrCallback :: MonadIO m => RepoCommitModifierXattrCallback -> m (GClosure C_RepoCommitModifierXattrCallback) +genClosure_RepoCommitModifierXattrCallback cb = liftIO $ do + let cb' = drop_closures_RepoCommitModifierXattrCallback cb + let cb'' = wrap_RepoCommitModifierXattrCallback Nothing cb' + mk_RepoCommitModifierXattrCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `RepoCommitModifierXattrCallback` into a `C_RepoCommitModifierXattrCallback`. +wrap_RepoCommitModifierXattrCallback :: + Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback)) -> + RepoCommitModifierXattrCallback_WithClosures -> + C_RepoCommitModifierXattrCallback +wrap_RepoCommitModifierXattrCallback funptrptr _cb repo path fileInfo userData = do + repo' <- (newObject OSTree.Repo.Repo) repo + path' <- cstringToText path + fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo + result <- _cb repo' path' fileInfo' userData + maybeReleaseFunPtr funptrptr + result' <- B.GVariant.disownGVariant result + return result' + + +-- callback RepoCommitFilter +-- -> Callable {returnType = Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitFilterResult"})), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "#OstreeRepoCommitFilterResult saying whether or not to commit this file", sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_RepoCommitFilter = + Ptr OSTree.Repo.Repo -> + CString -> + Ptr Gio.FileInfo.FileInfo -> + Ptr () -> + IO CUInt + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitFilterResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RepoCommitFilter :: FunPtr C_RepoCommitFilter -> C_RepoCommitFilter + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RepoCommitFilter :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) => + FunPtr C_RepoCommitFilter + -> a + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> b + {- ^ /@fileInfo@/: File information -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> m OSTree.Enums.RepoCommitFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -} +dynamic_RepoCommitFilter __funPtr repo path fileInfo userData = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + path' <- textToCString path + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + result <- (__dynamic_C_RepoCommitFilter __funPtr) repo' path' fileInfo' userData + let result' = (toEnum . fromIntegral) result + touchManagedPtr repo + touchManagedPtr fileInfo + freeMem path' + return result' + +-- | Generate a function pointer callable from C code, from a `C_RepoCommitFilter`. +foreign import ccall "wrapper" + mk_RepoCommitFilter :: C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter) + +{- | +/No description available in the introspection data./ +-} +type RepoCommitFilter = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> Gio.FileInfo.FileInfo + {- ^ /@fileInfo@/: File information -} + -> IO OSTree.Enums.RepoCommitFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter`@. +noRepoCommitFilter :: Maybe RepoCommitFilter +noRepoCommitFilter = Nothing + +{- | +/No description available in the introspection data./ +-} +type RepoCommitFilter_WithClosures = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> Gio.FileInfo.FileInfo + {- ^ /@fileInfo@/: File information -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> IO OSTree.Enums.RepoCommitFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter_WithClosures`@. +noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures +noRepoCommitFilter_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures +drop_closures_RepoCommitFilter _f repo path fileInfo _ = _f repo path fileInfo + +-- | Wrap the callback into a `GClosure`. +genClosure_RepoCommitFilter :: MonadIO m => RepoCommitFilter -> m (GClosure C_RepoCommitFilter) +genClosure_RepoCommitFilter cb = liftIO $ do + let cb' = drop_closures_RepoCommitFilter cb + let cb'' = wrap_RepoCommitFilter Nothing cb' + mk_RepoCommitFilter cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `RepoCommitFilter` into a `C_RepoCommitFilter`. +wrap_RepoCommitFilter :: + Maybe (Ptr (FunPtr C_RepoCommitFilter)) -> + RepoCommitFilter_WithClosures -> + C_RepoCommitFilter +wrap_RepoCommitFilter funptrptr _cb repo path fileInfo userData = do + repo' <- (newObject OSTree.Repo.Repo) repo + path' <- cstringToText path + fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo + result <- _cb repo' path' fileInfo' userData + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback RepoCheckoutFilter +-- -> Callable {returnType = Just (TInterface (Name {namespace = "OSTree", name = "RepoCheckoutFilterResult"})), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "#OstreeRepoCheckoutFilterResult saying whether or not to checkout this file", sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Just "2018.2"}} +-- | Type for the callback on the (unwrapped) C side. +type C_RepoCheckoutFilter = + Ptr OSTree.Repo.Repo -> + CString -> + Ptr () -> + Ptr () -> + IO CUInt + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCheckoutFilterResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RepoCheckoutFilter :: FunPtr C_RepoCheckoutFilter -> C_RepoCheckoutFilter + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RepoCheckoutFilter :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + FunPtr C_RepoCheckoutFilter + -> a + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> Ptr () + {- ^ /@stbuf@/: File information -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> m OSTree.Enums.RepoCheckoutFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -} +dynamic_RepoCheckoutFilter __funPtr repo path stbuf userData = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + path' <- textToCString path + result <- (__dynamic_C_RepoCheckoutFilter __funPtr) repo' path' stbuf userData + let result' = (toEnum . fromIntegral) result + touchManagedPtr repo + freeMem path' + return result' + +-- | Generate a function pointer callable from C code, from a `C_RepoCheckoutFilter`. +foreign import ccall "wrapper" + mk_RepoCheckoutFilter :: C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter) + +{- | +/No description available in the introspection data./ + +/Since: 2018.2/ +-} +type RepoCheckoutFilter = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> Ptr () + {- ^ /@stbuf@/: File information -} + -> IO OSTree.Enums.RepoCheckoutFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter`@. +noRepoCheckoutFilter :: Maybe RepoCheckoutFilter +noRepoCheckoutFilter = Nothing + +{- | +/No description available in the introspection data./ + +/Since: 2018.2/ +-} +type RepoCheckoutFilter_WithClosures = + OSTree.Repo.Repo + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@path@/: Path to file -} + -> Ptr () + {- ^ /@stbuf@/: File information -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> IO OSTree.Enums.RepoCheckoutFilterResult + {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter_WithClosures`@. +noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures +noRepoCheckoutFilter_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures +drop_closures_RepoCheckoutFilter _f repo path stbuf _ = _f repo path stbuf + +-- | Wrap the callback into a `GClosure`. +genClosure_RepoCheckoutFilter :: MonadIO m => RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter) +genClosure_RepoCheckoutFilter cb = liftIO $ do + let cb' = drop_closures_RepoCheckoutFilter cb + let cb'' = wrap_RepoCheckoutFilter Nothing cb' + mk_RepoCheckoutFilter cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `RepoCheckoutFilter` into a `C_RepoCheckoutFilter`. +wrap_RepoCheckoutFilter :: + Maybe (Ptr (FunPtr C_RepoCheckoutFilter)) -> + RepoCheckoutFilter_WithClosures -> + C_RepoCheckoutFilter +wrap_RepoCheckoutFilter funptrptr _cb repo path stbuf userData = do + repo' <- (newObject OSTree.Repo.Repo) repo + path' <- cstringToText path + result <- _cb repo' path' stbuf userData + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback CmdPrivateVTableOstreeSystemGeneratorFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "ostree_cmdline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "normal_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "early_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "late_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback = + CString -> + CString -> + CString -> + CString -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "ostree_cmdline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "normal_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "early_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "late_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback :: FunPtr C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback -> C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback + -> T.Text + -> T.Text + -> T.Text + -> T.Text + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback __funPtr ostreeCmdline normalDir earlyDir lateDir = liftIO $ do + ostreeCmdline' <- textToCString ostreeCmdline + normalDir' <- textToCString normalDir + earlyDir' <- textToCString earlyDir + lateDir' <- textToCString lateDir + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback __funPtr) ostreeCmdline' normalDir' earlyDir' lateDir' + freeMem ostreeCmdline' + freeMem normalDir' + freeMem earlyDir' + freeMem lateDir' + return () + ) (do + freeMem ostreeCmdline' + freeMem normalDir' + freeMem earlyDir' + freeMem lateDir' + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeSystemGeneratorFieldCallback :: C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeSystemGeneratorFieldCallback = + T.Text + -> T.Text + -> T.Text + -> T.Text + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeSystemGeneratorFieldCallback`@. +noCmdPrivateVTableOstreeSystemGeneratorFieldCallback :: Maybe CmdPrivateVTableOstreeSystemGeneratorFieldCallback +noCmdPrivateVTableOstreeSystemGeneratorFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_exists", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback = + Ptr OSTree.Repo.Repo -> + CString -> + CInt -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_exists", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) => + FunPtr C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback + -> a + -> T.Text + -> Bool + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback __funPtr repo deltaId outExists cancellable = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + deltaId' <- textToCString deltaId + let outExists' = (fromIntegral . fromEnum) outExists + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback __funPtr) repo' deltaId' outExists' cancellable' + touchManagedPtr repo + touchManagedPtr cancellable + freeMem deltaId' + return () + ) (do + freeMem deltaId' + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback = + OSTree.Repo.Repo + -> T.Text + -> Bool + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback`@. +noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback +noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback = + Ptr OSTree.Repo.Repo -> + CString -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) => + FunPtr C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback + -> a + -> T.Text + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback __funPtr repo deltaId cancellable = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + deltaId' <- textToCString deltaId + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback __funPtr) repo' deltaId' cancellable' + touchManagedPtr repo + touchManagedPtr cancellable + freeMem deltaId' + return () + ) (do + freeMem deltaId' + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback = + OSTree.Repo.Repo + -> T.Text + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback`@. +noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback +noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback = + Ptr OSTree.Repo.Repo -> + CString -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) => + FunPtr C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback + -> a + -> T.Text + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback __funPtr repo deltaId cancellable = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + deltaId' <- textToCString deltaId + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback __funPtr) repo' deltaId' cancellable' + touchManagedPtr repo + touchManagedPtr cancellable + freeMem deltaId' + return () + ) (do + freeMem deltaId' + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback = + OSTree.Repo.Repo + -> T.Text + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback`@. +noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback +noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback = + CString -> + CString -> + Ptr GVariant -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: FunPtr C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback -> C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback + -> T.Text + -> T.Text + -> GVariant + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback __funPtr collectionId refName commit = liftIO $ do + collectionId' <- textToCString collectionId + refName' <- textToCString refName + commit' <- unsafeManagedPtrGetPtr commit + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback __funPtr) collectionId' refName' commit' + touchManagedPtr commit + freeMem collectionId' + freeMem refName' + return () + ) (do + freeMem collectionId' + freeMem refName' + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback = + T.Text + -> T.Text + -> GVariant + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback`@. +noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: Maybe CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback +noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bootversion", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback = + Ptr OSTree.Sysroot.Sysroot -> + Int32 -> + Int32 -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bootversion", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: FunPtr C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback -> C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) => + FunPtr C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback + -> a + -> Int32 + -> Int32 + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback __funPtr sysroot bootversion targetFd cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback __funPtr) sysroot' bootversion targetFd cancellable' + touchManagedPtr sysroot + touchManagedPtr cancellable + return () + ) (do + return () + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback = + OSTree.Sysroot.Sysroot + -> Int32 + -> Int32 + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback`@. +noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: Maybe CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback +noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback CmdPrivateVTableOstreeFinalizeStagedFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback = + Ptr OSTree.Sysroot.Sysroot -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback :: FunPtr C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback -> C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) => + FunPtr C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback + -> a + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback __funPtr sysroot cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback __funPtr) sysroot' cancellable' + touchManagedPtr sysroot + touchManagedPtr cancellable + return () + ) (do + return () + ) + +-- | Generate a function pointer callable from C code, from a `C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback`. +foreign import ccall "wrapper" + mk_CmdPrivateVTableOstreeFinalizeStagedFieldCallback :: C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback -> IO (FunPtr C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type CmdPrivateVTableOstreeFinalizeStagedFieldCallback = + OSTree.Sysroot.Sysroot + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeFinalizeStagedFieldCallback`@. +noCmdPrivateVTableOstreeFinalizeStagedFieldCallback :: Maybe CmdPrivateVTableOstreeFinalizeStagedFieldCallback +noCmdPrivateVTableOstreeFinalizeStagedFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback BootloaderInterfaceQueryFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "bootloader", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_is_active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_BootloaderInterfaceQueryFieldCallback = + Ptr OSTree.Bootloader.Bootloader -> + CInt -> + Ptr Gio.Cancellable.Cancellable -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "bootloader", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_is_active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_BootloaderInterfaceQueryFieldCallback :: FunPtr C_BootloaderInterfaceQueryFieldCallback -> C_BootloaderInterfaceQueryFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_BootloaderInterfaceQueryFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + FunPtr C_BootloaderInterfaceQueryFieldCallback + -> OSTree.Bootloader.Bootloader + -> Bool + -> a + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_BootloaderInterfaceQueryFieldCallback __funPtr bootloader outIsActive cancellable = liftIO $ do + bootloader' <- unsafeManagedPtrGetPtr bootloader + let outIsActive' = (fromIntegral . fromEnum) outIsActive + cancellable' <- unsafeManagedPtrCastPtr cancellable + onException (do + _ <- propagateGError $ (__dynamic_C_BootloaderInterfaceQueryFieldCallback __funPtr) bootloader' outIsActive' cancellable' + touchManagedPtr bootloader + touchManagedPtr cancellable + return () + ) (do + return () + ) + +-- | Generate a function pointer callable from C code, from a `C_BootloaderInterfaceQueryFieldCallback`. +foreign import ccall "wrapper" + mk_BootloaderInterfaceQueryFieldCallback :: C_BootloaderInterfaceQueryFieldCallback -> IO (FunPtr C_BootloaderInterfaceQueryFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type BootloaderInterfaceQueryFieldCallback = + OSTree.Bootloader.Bootloader + -> Bool + -> Gio.Cancellable.Cancellable + -> IO () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceQueryFieldCallback`@. +noBootloaderInterfaceQueryFieldCallback :: Maybe BootloaderInterfaceQueryFieldCallback +noBootloaderInterfaceQueryFieldCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback BootloaderInterfaceIsAtomicFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_BootloaderInterfaceIsAtomicFieldCallback = + Ptr OSTree.Bootloader.Bootloader -> + IO CInt + +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_BootloaderInterfaceIsAtomicFieldCallback :: FunPtr C_BootloaderInterfaceIsAtomicFieldCallback -> C_BootloaderInterfaceIsAtomicFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_BootloaderInterfaceIsAtomicFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_BootloaderInterfaceIsAtomicFieldCallback + -> OSTree.Bootloader.Bootloader + -> m Bool +dynamic_BootloaderInterfaceIsAtomicFieldCallback __funPtr self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- (__dynamic_C_BootloaderInterfaceIsAtomicFieldCallback __funPtr) self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +-- | Generate a function pointer callable from C code, from a `C_BootloaderInterfaceIsAtomicFieldCallback`. +foreign import ccall "wrapper" + mk_BootloaderInterfaceIsAtomicFieldCallback :: C_BootloaderInterfaceIsAtomicFieldCallback -> IO (FunPtr C_BootloaderInterfaceIsAtomicFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type BootloaderInterfaceIsAtomicFieldCallback = + OSTree.Bootloader.Bootloader + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceIsAtomicFieldCallback`@. +noBootloaderInterfaceIsAtomicFieldCallback :: Maybe BootloaderInterfaceIsAtomicFieldCallback +noBootloaderInterfaceIsAtomicFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_BootloaderInterfaceIsAtomicFieldCallback :: MonadIO m => BootloaderInterfaceIsAtomicFieldCallback -> m (GClosure C_BootloaderInterfaceIsAtomicFieldCallback) +genClosure_BootloaderInterfaceIsAtomicFieldCallback cb = liftIO $ do + let cb' = wrap_BootloaderInterfaceIsAtomicFieldCallback Nothing cb + mk_BootloaderInterfaceIsAtomicFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BootloaderInterfaceIsAtomicFieldCallback` into a `C_BootloaderInterfaceIsAtomicFieldCallback`. +wrap_BootloaderInterfaceIsAtomicFieldCallback :: + Maybe (Ptr (FunPtr C_BootloaderInterfaceIsAtomicFieldCallback)) -> + BootloaderInterfaceIsAtomicFieldCallback -> + C_BootloaderInterfaceIsAtomicFieldCallback +wrap_BootloaderInterfaceIsAtomicFieldCallback funptrptr _cb self = do + self' <- (newPtr OSTree.Bootloader.Bootloader) self + result <- _cb self' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback BootloaderInterfaceGetNameFieldCallback +-- -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_BootloaderInterfaceGetNameFieldCallback = + Ptr OSTree.Bootloader.Bootloader -> + IO CString + +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_BootloaderInterfaceGetNameFieldCallback :: FunPtr C_BootloaderInterfaceGetNameFieldCallback -> C_BootloaderInterfaceGetNameFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_BootloaderInterfaceGetNameFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_BootloaderInterfaceGetNameFieldCallback + -> OSTree.Bootloader.Bootloader + -> m T.Text +dynamic_BootloaderInterfaceGetNameFieldCallback __funPtr self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- (__dynamic_C_BootloaderInterfaceGetNameFieldCallback __funPtr) self' + checkUnexpectedReturnNULL "bootloaderInterfaceGetNameFieldCallback" result + result' <- cstringToText result + touchManagedPtr self + return result' + +-- | Generate a function pointer callable from C code, from a `C_BootloaderInterfaceGetNameFieldCallback`. +foreign import ccall "wrapper" + mk_BootloaderInterfaceGetNameFieldCallback :: C_BootloaderInterfaceGetNameFieldCallback -> IO (FunPtr C_BootloaderInterfaceGetNameFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type BootloaderInterfaceGetNameFieldCallback = + OSTree.Bootloader.Bootloader + -> IO T.Text + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceGetNameFieldCallback`@. +noBootloaderInterfaceGetNameFieldCallback :: Maybe BootloaderInterfaceGetNameFieldCallback +noBootloaderInterfaceGetNameFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_BootloaderInterfaceGetNameFieldCallback :: MonadIO m => BootloaderInterfaceGetNameFieldCallback -> m (GClosure C_BootloaderInterfaceGetNameFieldCallback) +genClosure_BootloaderInterfaceGetNameFieldCallback cb = liftIO $ do + let cb' = wrap_BootloaderInterfaceGetNameFieldCallback Nothing cb + mk_BootloaderInterfaceGetNameFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BootloaderInterfaceGetNameFieldCallback` into a `C_BootloaderInterfaceGetNameFieldCallback`. +wrap_BootloaderInterfaceGetNameFieldCallback :: + Maybe (Ptr (FunPtr C_BootloaderInterfaceGetNameFieldCallback)) -> + BootloaderInterfaceGetNameFieldCallback -> + C_BootloaderInterfaceGetNameFieldCallback +wrap_BootloaderInterfaceGetNameFieldCallback funptrptr _cb self = do + self' <- (newPtr OSTree.Bootloader.Bootloader) self + result <- _cb self' + maybeReleaseFunPtr funptrptr + result' <- textToCString result + return result' + + + diff --git a/GI/OSTree/Constants.hs b/GI/OSTree/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Constants.hs @@ -0,0 +1,270 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Constants + ( + pattern YEAR_VERSION , + pattern VERSION_S , + pattern VERSION , + pattern TREE_GVARIANT_STRING , + pattern TIMESTAMP , + pattern SUMMARY_SIG_GVARIANT_STRING , + pattern SUMMARY_GVARIANT_STRING , + pattern SHA256_STRING_LEN , + pattern SHA256_DIGEST_LEN , + pattern REPO_METADATA_REF , + pattern RELEASE_VERSION , + pattern ORIGIN_TRANSIENT_GROUP , + pattern META_KEY_DEPLOY_COLLECTION_ID , + pattern MAX_METADATA_WARN_SIZE , + pattern MAX_METADATA_SIZE , + pattern FILEMETA_GVARIANT_STRING , + pattern DIRMETA_GVARIANT_STRING , + pattern COMMIT_META_KEY_VERSION , + pattern COMMIT_META_KEY_SOURCE_TITLE , + pattern COMMIT_META_KEY_REF_BINDING , + pattern COMMIT_META_KEY_ENDOFLIFE_REBASE, + pattern COMMIT_META_KEY_ENDOFLIFE , + pattern COMMIT_META_KEY_COLLECTION_BINDING, + pattern COMMIT_GVARIANT_STRING , + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +{- | +ostree year version component (e.g. 2017 if 'GI.OSTree.Constants.VERSION' is 2017.2) + +/Since: 2017.4/ +-} +pattern YEAR_VERSION = 2019 :: Int32 + +{- | +ostree version, encoded as a string, useful for printing and +concatenation. + +/Since: 2017.4/ +-} +pattern VERSION_S = "2019.2" :: T.Text + +{- | +ostree version. + +/Since: 2017.4/ +-} +pattern VERSION = 2019.200000 :: Double + +{- | +/No description available in the introspection data./ +-} +pattern TREE_GVARIANT_STRING = "(a(say)a(sayay))" :: T.Text + +{- | +The mtime used for stored files. This was originally 0, changed to 1 for +a few releases, then was reverted due to regressions it introduced from +users who had been using zero before. +-} +pattern TIMESTAMP = 0 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern SUMMARY_SIG_GVARIANT_STRING = "a{sv}" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern SUMMARY_GVARIANT_STRING = "(a(s(taya{sv}))a{sv})" :: T.Text + +{- | +Length of a sha256 digest when expressed as a hexadecimal string +-} +pattern SHA256_STRING_LEN = 64 :: Int32 + +{- | +Length of a sha256 digest when expressed as raw bytes +-} +pattern SHA256_DIGEST_LEN = 32 :: Int32 + +{- | +The name of a ref which is used to store metadata for the entire repository, +such as its expected update time (@ostree.summary.expires@), name, or new +GPG keys. Metadata is stored on contentless commits in the ref, and hence is +signed with the commits. + +This supersedes the additional metadata dictionary in the @summary@ file +(see 'GI.OSTree.Objects.Repo.repoRegenerateSummary'), as the use of a ref means that the +metadata for multiple upstream repositories can be included in a single mirror +repository, disambiguating the refs using collection IDs. In order to support +peer to peer redistribution of repository metadata, repositories must set a +collection ID ('GI.OSTree.Objects.Repo.repoSetCollectionId'). + +Users of OSTree may place arbitrary metadata in commits on this ref, but the +keys must be namespaced by product or developer. For example, +@exampleos.end-of-life@. The @ostree.@ prefix is reserved. + +/Since: 2018.6/ +-} +pattern REPO_METADATA_REF = "ostree-metadata" :: T.Text + +{- | +ostree release version component (e.g. 2 if 'GI.OSTree.Constants.VERSION' is 2017.2) + +/Since: 2017.4/ +-} +pattern RELEASE_VERSION = 2 :: Int32 + +{- | +The name of a @GKeyFile@ group for data that should not +be carried across upgrades. For more information, +see 'GI.OSTree.Objects.Deployment.deploymentOriginRemoveTransientState'. + +/Since: 2018.3/ +-} +pattern ORIGIN_TRANSIENT_GROUP = "libostree-transient" :: T.Text + +{- | +GVariant type @s@. This key can be used in the repo metadata which is stored +in OSTREE_REPO_METADATA_REF as well as in the summary. The semantics of this +are that the remote repository wants clients to update their remote config +to add this collection ID (clients can\'t do P2P operations involving a +remote without a collection ID configured on it, even if one is configured +on the server side). Clients must never change or remove a collection ID +already set in their remote config. + +Currently, OSTree does not implement changing a remote config based on this +key, but it may do so in a later release, and until then clients such as +Flatpak may implement it. + +This is a replacement for the similar metadata key implemented by flatpak, +@xa.collection-id@, which is now deprecated as clients which supported it had +bugs with their P2P implementations. + +/Since: 2018.9/ +-} +pattern META_KEY_DEPLOY_COLLECTION_ID = "ostree.deploy-collection-id" :: T.Text + +{- | +This variable is no longer meaningful, it is kept only for compatibility. +-} +pattern MAX_METADATA_WARN_SIZE = 7340032 :: Int32 + +{- | +Default limit for maximum permitted size in bytes of metadata objects fetched +over HTTP (including repo\/config files, refs, and commit\/dirtree\/dirmeta +objects). This is an arbitrary number intended to mitigate disk space +exhaustion attacks. +-} +pattern MAX_METADATA_SIZE = 10485760 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern FILEMETA_GVARIANT_STRING = "(uuua(ayay))" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern DIRMETA_GVARIANT_STRING = "(uuua(ayay))" :: T.Text + +{- | +GVariant type @s@. This metadata key is used for version numbers. A freeform +string; the intention is that systems using ostree do not interpret this +semantically as traditional package managers do. + +This is the only ostree-defined metadata key that does not start with @ostree.@. + +/Since: 2014.9/ +-} +pattern COMMIT_META_KEY_VERSION = "version" :: T.Text + +{- | +GVariant type @s@. This should hold a relatively short single line value +containing a human-readable \"source\" for a commit, intended to be displayed +near the origin ref. This is particularly useful for systems that inject +content into an OSTree commit from elsewhere - for example, generating from +an OCI or qcow2 image. Or if generating from packages, the enabled repository +names and their versions. + +Try to keep this key short (e.g. \< 80 characters) and human-readable; if you +desire machine readable data, consider injecting separate metadata keys. + +/Since: 2017.13/ +-} +pattern COMMIT_META_KEY_SOURCE_TITLE = "ostree.source-title" :: T.Text + +{- | +GVariant type @as@; each element is a branch name. If this is added to a +commit, @ostree_repo_pull()@ will enforce that the commit was retrieved from +one of the branch names in this array. This prevents \"sidegrade\" attacks. +The rationale for having this support multiple branch names is that it helps +support a \"promotion\" model of taking a commit and moving it between development +and production branches. + +/Since: 2017.9/ +-} +pattern COMMIT_META_KEY_REF_BINDING = "ostree.ref-binding" :: T.Text + +{- | +GVariant type @s@. Should contain a refspec defining a new target branch; +@ostree admin upgrade@ and @OstreeSysrootUpgrader@ will automatically initiate +a rebase upon encountering this metadata key. + +/Since: 2017.7/ +-} +pattern COMMIT_META_KEY_ENDOFLIFE_REBASE = "ostree.endoflife-rebase" :: T.Text + +{- | +GVariant type @s@. This metadata key is used to display vendor\'s message +when an update stream for a particular branch ends. It usually provides +update instructions for the users. + +/Since: 2017.7/ +-} +pattern COMMIT_META_KEY_ENDOFLIFE = "ostree.endoflife" :: T.Text + +{- | +GVariant type @s@. If this is added to a commit, @ostree_repo_pull()@ +will enforce that the commit was retrieved from a repository which has +the same collection ID. See @ostree_repo_set_collection_id()@. +This is most useful in concert with @OSTREE_COMMIT_META_KEY_REF_BINDING@, +as it more strongly binds the commit to the repository and branch. + +/Since: 2018.6/ +-} +pattern COMMIT_META_KEY_COLLECTION_BINDING = "ostree.collection-binding" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern COMMIT_GVARIANT_STRING = "(a{sv}aya(say)sstayay)" :: T.Text + + diff --git a/GI/OSTree/Enums.hs b/GI/OSTree/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Enums.hs @@ -0,0 +1,721 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Enums + ( + + -- * Enumerations +-- ** DeploymentUnlockedState #enum:DeploymentUnlockedState# + + DeploymentUnlockedState(..) , + + +-- ** GpgError #enum:GpgError# + + GpgError(..) , + catchGpgError , + handleGpgError , + + +-- ** GpgSignatureAttr #enum:GpgSignatureAttr# + + GpgSignatureAttr(..) , + + +-- ** GpgSignatureFormatFlags #enum:GpgSignatureFormatFlags# + + GpgSignatureFormatFlags(..) , + + +-- ** ObjectType #enum:ObjectType# + + ObjectType(..) , + + +-- ** RepoCheckoutFilterResult #enum:RepoCheckoutFilterResult# + + RepoCheckoutFilterResult(..) , + + +-- ** RepoCheckoutMode #enum:RepoCheckoutMode# + + RepoCheckoutMode(..) , + + +-- ** RepoCheckoutOverwriteMode #enum:RepoCheckoutOverwriteMode# + + RepoCheckoutOverwriteMode(..) , + + +-- ** RepoCommitFilterResult #enum:RepoCommitFilterResult# + + RepoCommitFilterResult(..) , + + +-- ** RepoCommitIterResult #enum:RepoCommitIterResult# + + RepoCommitIterResult(..) , + + +-- ** RepoMode #enum:RepoMode# + + RepoMode(..) , + + +-- ** RepoPruneFlags #enum:RepoPruneFlags# + + RepoPruneFlags(..) , + + +-- ** RepoRemoteChange #enum:RepoRemoteChange# + + RepoRemoteChange(..) , + + +-- ** StaticDeltaGenerateOpt #enum:StaticDeltaGenerateOpt# + + StaticDeltaGenerateOpt(..) , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- Enum StaticDeltaGenerateOpt +{- | +Parameters controlling optimization of static deltas. +-} +data StaticDeltaGenerateOpt = + StaticDeltaGenerateOptLowlatency + {- ^ + Optimize for speed of delta creation over space + -} + | StaticDeltaGenerateOptMajor + {- ^ + Optimize for delta size (may be very slow) + -} + | AnotherStaticDeltaGenerateOpt Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StaticDeltaGenerateOpt where + fromEnum StaticDeltaGenerateOptLowlatency = 0 + fromEnum StaticDeltaGenerateOptMajor = 1 + fromEnum (AnotherStaticDeltaGenerateOpt k) = k + + toEnum 0 = StaticDeltaGenerateOptLowlatency + toEnum 1 = StaticDeltaGenerateOptMajor + toEnum k = AnotherStaticDeltaGenerateOpt k + +instance P.Ord StaticDeltaGenerateOpt where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoRemoteChange +{- | +The remote change operation. +-} +data RepoRemoteChange = + RepoRemoteChangeAdd + {- ^ + Add a remote + -} + | RepoRemoteChangeAddIfNotExists + {- ^ + Like above, but do nothing if the remote exists + -} + | RepoRemoteChangeDelete + {- ^ + Delete a remote + -} + | RepoRemoteChangeDeleteIfExists + {- ^ + Delete a remote, do nothing if the remote does not exist + -} + | RepoRemoteChangeReplace + {- ^ + Add or replace a remote (Since: 2019.2) + -} + | AnotherRepoRemoteChange Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoRemoteChange where + fromEnum RepoRemoteChangeAdd = 0 + fromEnum RepoRemoteChangeAddIfNotExists = 1 + fromEnum RepoRemoteChangeDelete = 2 + fromEnum RepoRemoteChangeDeleteIfExists = 3 + fromEnum RepoRemoteChangeReplace = 4 + fromEnum (AnotherRepoRemoteChange k) = k + + toEnum 0 = RepoRemoteChangeAdd + toEnum 1 = RepoRemoteChangeAddIfNotExists + toEnum 2 = RepoRemoteChangeDelete + toEnum 3 = RepoRemoteChangeDeleteIfExists + toEnum 4 = RepoRemoteChangeReplace + toEnum k = AnotherRepoRemoteChange k + +instance P.Ord RepoRemoteChange where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoPruneFlags +{- | +/No description available in the introspection data./ +-} +data RepoPruneFlags = + RepoPruneFlagsNone + {- ^ + No special options for pruning + -} + | RepoPruneFlagsNoPrune + {- ^ + Don\'t actually delete objects + -} + | RepoPruneFlagsRefsOnly + {- ^ + Do not traverse individual commit objects, only follow refs + -} + | AnotherRepoPruneFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoPruneFlags where + fromEnum RepoPruneFlagsNone = 0 + fromEnum RepoPruneFlagsNoPrune = 1 + fromEnum RepoPruneFlagsRefsOnly = 2 + fromEnum (AnotherRepoPruneFlags k) = k + + toEnum 0 = RepoPruneFlagsNone + toEnum 1 = RepoPruneFlagsNoPrune + toEnum 2 = RepoPruneFlagsRefsOnly + toEnum k = AnotherRepoPruneFlags k + +instance P.Ord RepoPruneFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoMode +{- | +See the documentation of 'GI.OSTree.Objects.Repo.Repo' for more information about the +possible modes. +-} +data RepoMode = + RepoModeBare + {- ^ + Files are stored as themselves; checkouts are hardlinks; can only be written as root + -} + | RepoModeArchive + {- ^ + Files are compressed, should be owned by non-root. Can be served via HTTP. Since: 2017.12 + -} + | RepoModeArchiveZ2 + {- ^ + Legacy alias for @OSTREE_REPO_MODE_ARCHIVE@ + -} + | RepoModeBareUser + {- ^ + Files are stored as themselves, except ownership; can be written by user. Hardlinks work only in user checkouts. + -} + | RepoModeBareUserOnly + {- ^ + Same as BARE_USER, but all metadata is not stored, so it can only be used for user checkouts. Does not need xattrs. + -} + | AnotherRepoMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoMode where + fromEnum RepoModeBare = 0 + fromEnum RepoModeArchive = 1 + fromEnum RepoModeArchiveZ2 = 1 + fromEnum RepoModeBareUser = 2 + fromEnum RepoModeBareUserOnly = 3 + fromEnum (AnotherRepoMode k) = k + + toEnum 0 = RepoModeBare + toEnum 1 = RepoModeArchive + toEnum 1 = RepoModeArchiveZ2 + toEnum 2 = RepoModeBareUser + toEnum 3 = RepoModeBareUserOnly + toEnum k = AnotherRepoMode k + +instance P.Ord RepoMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoCommitIterResult +{- | +/No description available in the introspection data./ +-} +data RepoCommitIterResult = + RepoCommitIterResultError + {- ^ + /No description available in the introspection data./ + -} + | RepoCommitIterResultEnd + {- ^ + /No description available in the introspection data./ + -} + | RepoCommitIterResultFile + {- ^ + /No description available in the introspection data./ + -} + | RepoCommitIterResultDir + {- ^ + /No description available in the introspection data./ + -} + | AnotherRepoCommitIterResult Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCommitIterResult where + fromEnum RepoCommitIterResultError = 0 + fromEnum RepoCommitIterResultEnd = 1 + fromEnum RepoCommitIterResultFile = 2 + fromEnum RepoCommitIterResultDir = 3 + fromEnum (AnotherRepoCommitIterResult k) = k + + toEnum 0 = RepoCommitIterResultError + toEnum 1 = RepoCommitIterResultEnd + toEnum 2 = RepoCommitIterResultFile + toEnum 3 = RepoCommitIterResultDir + toEnum k = AnotherRepoCommitIterResult k + +instance P.Ord RepoCommitIterResult where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoCommitFilterResult +{- | +/No description available in the introspection data./ +-} +data RepoCommitFilterResult = + RepoCommitFilterResultAllow + {- ^ + Do commit this object + -} + | RepoCommitFilterResultSkip + {- ^ + Ignore this object + -} + | AnotherRepoCommitFilterResult Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCommitFilterResult where + fromEnum RepoCommitFilterResultAllow = 0 + fromEnum RepoCommitFilterResultSkip = 1 + fromEnum (AnotherRepoCommitFilterResult k) = k + + toEnum 0 = RepoCommitFilterResultAllow + toEnum 1 = RepoCommitFilterResultSkip + toEnum k = AnotherRepoCommitFilterResult k + +instance P.Ord RepoCommitFilterResult where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoCheckoutOverwriteMode +{- | +/No description available in the introspection data./ +-} +data RepoCheckoutOverwriteMode = + RepoCheckoutOverwriteModeNone + {- ^ + No special options + -} + | RepoCheckoutOverwriteModeUnionFiles + {- ^ + When layering checkouts, @/unlink()/@ and replace existing files, but do not modify existing directories (unless whiteouts are enabled, then directories are replaced) + -} + | RepoCheckoutOverwriteModeAddFiles + {- ^ + Only add new files\/directories + -} + | RepoCheckoutOverwriteModeUnionIdentical + {- ^ + Like UNION_FILES, but error if files are not identical (requires hardlink checkouts) + -} + | AnotherRepoCheckoutOverwriteMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCheckoutOverwriteMode where + fromEnum RepoCheckoutOverwriteModeNone = 0 + fromEnum RepoCheckoutOverwriteModeUnionFiles = 1 + fromEnum RepoCheckoutOverwriteModeAddFiles = 2 + fromEnum RepoCheckoutOverwriteModeUnionIdentical = 3 + fromEnum (AnotherRepoCheckoutOverwriteMode k) = k + + toEnum 0 = RepoCheckoutOverwriteModeNone + toEnum 1 = RepoCheckoutOverwriteModeUnionFiles + toEnum 2 = RepoCheckoutOverwriteModeAddFiles + toEnum 3 = RepoCheckoutOverwriteModeUnionIdentical + toEnum k = AnotherRepoCheckoutOverwriteMode k + +instance P.Ord RepoCheckoutOverwriteMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoCheckoutMode +{- | +/No description available in the introspection data./ +-} +data RepoCheckoutMode = + RepoCheckoutModeNone + {- ^ + No special options + -} + | RepoCheckoutModeUser + {- ^ + Ignore uid\/gid of files + -} + | AnotherRepoCheckoutMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCheckoutMode where + fromEnum RepoCheckoutModeNone = 0 + fromEnum RepoCheckoutModeUser = 1 + fromEnum (AnotherRepoCheckoutMode k) = k + + toEnum 0 = RepoCheckoutModeNone + toEnum 1 = RepoCheckoutModeUser + toEnum k = AnotherRepoCheckoutMode k + +instance P.Ord RepoCheckoutMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepoCheckoutFilterResult +{- | +/No description available in the introspection data./ + +/Since: 2018.2/ +-} +data RepoCheckoutFilterResult = + RepoCheckoutFilterResultAllow + {- ^ + Do checkout this object + -} + | RepoCheckoutFilterResultSkip + {- ^ + Ignore this object + -} + | AnotherRepoCheckoutFilterResult Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCheckoutFilterResult where + fromEnum RepoCheckoutFilterResultAllow = 0 + fromEnum RepoCheckoutFilterResultSkip = 1 + fromEnum (AnotherRepoCheckoutFilterResult k) = k + + toEnum 0 = RepoCheckoutFilterResultAllow + toEnum 1 = RepoCheckoutFilterResultSkip + toEnum k = AnotherRepoCheckoutFilterResult k + +instance P.Ord RepoCheckoutFilterResult where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum ObjectType +{- | +Enumeration for core object types; 'GI.OSTree.Enums.ObjectTypeFile' is for +content, the other types are metadata. +-} +data ObjectType = + ObjectTypeFile + {- ^ + Content; regular file, symbolic link + -} + | ObjectTypeDirTree + {- ^ + List of children (trees or files), and metadata + -} + | ObjectTypeDirMeta + {- ^ + Directory metadata + -} + | ObjectTypeCommit + {- ^ + Toplevel object, refers to tree and dirmeta for root + -} + | ObjectTypeTombstoneCommit + {- ^ + Toplevel object, refers to a deleted commit + -} + | ObjectTypeCommitMeta + {- ^ + Detached metadata for a commit + -} + | ObjectTypePayloadLink + {- ^ + Symlink to a .file given its checksum on the payload only. + -} + | AnotherObjectType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ObjectType where + fromEnum ObjectTypeFile = 1 + fromEnum ObjectTypeDirTree = 2 + fromEnum ObjectTypeDirMeta = 3 + fromEnum ObjectTypeCommit = 4 + fromEnum ObjectTypeTombstoneCommit = 5 + fromEnum ObjectTypeCommitMeta = 6 + fromEnum ObjectTypePayloadLink = 7 + fromEnum (AnotherObjectType k) = k + + toEnum 1 = ObjectTypeFile + toEnum 2 = ObjectTypeDirTree + toEnum 3 = ObjectTypeDirMeta + toEnum 4 = ObjectTypeCommit + toEnum 5 = ObjectTypeTombstoneCommit + toEnum 6 = ObjectTypeCommitMeta + toEnum 7 = ObjectTypePayloadLink + toEnum k = AnotherObjectType k + +instance P.Ord ObjectType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum GpgSignatureFormatFlags +{- | +Formatting flags for 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultDescribe'. Currently +there\'s only one possible output format, but this enumeration allows +for future variations. +-} +data GpgSignatureFormatFlags = + GpgSignatureFormatFlagsGpgSignatureFormatDefault + {- ^ + Use the default output format + -} + | AnotherGpgSignatureFormatFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum GpgSignatureFormatFlags where + fromEnum GpgSignatureFormatFlagsGpgSignatureFormatDefault = 0 + fromEnum (AnotherGpgSignatureFormatFlags k) = k + + toEnum 0 = GpgSignatureFormatFlagsGpgSignatureFormatDefault + toEnum k = AnotherGpgSignatureFormatFlags k + +instance P.Ord GpgSignatureFormatFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum GpgSignatureAttr +{- | +Signature attributes available from an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'. +The attribute\'s 'GI.GLib.Structs.VariantType.VariantType' is shown in brackets. +-} +data GpgSignatureAttr = + GpgSignatureAttrValid + {- ^ + [@/G_VARIANT_TYPE_BOOLEAN/@] Is the signature valid? + -} + | GpgSignatureAttrSigExpired + {- ^ + [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signature expired? + -} + | GpgSignatureAttrKeyExpired + {- ^ + [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signing key expired? + -} + | GpgSignatureAttrKeyRevoked + {- ^ + [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signing key been revoked? + -} + | GpgSignatureAttrKeyMissing + {- ^ + [@/G_VARIANT_TYPE_BOOLEAN/@] Is the signing key missing? + -} + | GpgSignatureAttrFingerprint + {- ^ + [@/G_VARIANT_TYPE_STRING/@] Fingerprint of the signing key + -} + | GpgSignatureAttrTimestamp + {- ^ + [@/G_VARIANT_TYPE_INT64/@] Signature creation Unix timestamp + -} + | GpgSignatureAttrExpTimestamp + {- ^ + [@/G_VARIANT_TYPE_INT64/@] Signature expiration Unix timestamp (0 if no + expiration) + -} + | GpgSignatureAttrPubkeyAlgoName + {- ^ + [@/G_VARIANT_TYPE_STRING/@] Name of the public key algorithm used to create + the signature + -} + | GpgSignatureAttrHashAlgoName + {- ^ + [@/G_VARIANT_TYPE_STRING/@] Name of the hash algorithm used to create the + signature + -} + | GpgSignatureAttrUserName + {- ^ + [@/G_VARIANT_TYPE_STRING/@] The name of the signing key\'s primary user + -} + | GpgSignatureAttrUserEmail + {- ^ + [@/G_VARIANT_TYPE_STRING/@] The email address of the signing key\'s primary + user + -} + | GpgSignatureAttrFingerprintPrimary + {- ^ + [@/G_VARIANT_TYPE_STRING/@] Fingerprint of the signing key\'s primary key + (will be the same as OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT if the + the signature is already from the primary key rather than a subkey, + and will be the empty string if the key is missing.) + -} + | AnotherGpgSignatureAttr Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum GpgSignatureAttr where + fromEnum GpgSignatureAttrValid = 0 + fromEnum GpgSignatureAttrSigExpired = 1 + fromEnum GpgSignatureAttrKeyExpired = 2 + fromEnum GpgSignatureAttrKeyRevoked = 3 + fromEnum GpgSignatureAttrKeyMissing = 4 + fromEnum GpgSignatureAttrFingerprint = 5 + fromEnum GpgSignatureAttrTimestamp = 6 + fromEnum GpgSignatureAttrExpTimestamp = 7 + fromEnum GpgSignatureAttrPubkeyAlgoName = 8 + fromEnum GpgSignatureAttrHashAlgoName = 9 + fromEnum GpgSignatureAttrUserName = 10 + fromEnum GpgSignatureAttrUserEmail = 11 + fromEnum GpgSignatureAttrFingerprintPrimary = 12 + fromEnum (AnotherGpgSignatureAttr k) = k + + toEnum 0 = GpgSignatureAttrValid + toEnum 1 = GpgSignatureAttrSigExpired + toEnum 2 = GpgSignatureAttrKeyExpired + toEnum 3 = GpgSignatureAttrKeyRevoked + toEnum 4 = GpgSignatureAttrKeyMissing + toEnum 5 = GpgSignatureAttrFingerprint + toEnum 6 = GpgSignatureAttrTimestamp + toEnum 7 = GpgSignatureAttrExpTimestamp + toEnum 8 = GpgSignatureAttrPubkeyAlgoName + toEnum 9 = GpgSignatureAttrHashAlgoName + toEnum 10 = GpgSignatureAttrUserName + toEnum 11 = GpgSignatureAttrUserEmail + toEnum 12 = GpgSignatureAttrFingerprintPrimary + toEnum k = AnotherGpgSignatureAttr k + +instance P.Ord GpgSignatureAttr where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum GpgError +{- | +Errors returned by signature creation and verification operations in OSTree. +These may be returned by any API which creates or verifies signatures. + +/Since: 2017.10/ +-} +data GpgError = + GpgErrorNoSignature + {- ^ + A signature was expected, but not found. + -} + | GpgErrorInvalidSignature + {- ^ + A signature was malformed. + -} + | GpgErrorMissingKey + {- ^ + A signature was found, but was created with a key not in the configured keyrings. + -} + | AnotherGpgError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum GpgError where + fromEnum GpgErrorNoSignature = 0 + fromEnum GpgErrorInvalidSignature = 1 + fromEnum GpgErrorMissingKey = 2 + fromEnum (AnotherGpgError k) = k + + toEnum 0 = GpgErrorNoSignature + toEnum 1 = GpgErrorInvalidSignature + toEnum 2 = GpgErrorMissingKey + toEnum k = AnotherGpgError k + +instance P.Ord GpgError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass GpgError where + gerrorClassDomain _ = "OstreeGpgError" + +-- | Catch exceptions of type `GpgError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchGpgError :: + IO a -> + (GpgError -> GErrorMessage -> IO a) -> + IO a +catchGpgError = catchGErrorJustDomain + +-- | Handle exceptions of type `GpgError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleGpgError :: + (GpgError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleGpgError = handleGErrorJustDomain + +-- Enum DeploymentUnlockedState +{- | +/No description available in the introspection data./ +-} +data DeploymentUnlockedState = + DeploymentUnlockedStateNone + {- ^ + /No description available in the introspection data./ + -} + | DeploymentUnlockedStateDevelopment + {- ^ + /No description available in the introspection data./ + -} + | DeploymentUnlockedStateHotfix + {- ^ + /No description available in the introspection data./ + -} + | AnotherDeploymentUnlockedState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DeploymentUnlockedState where + fromEnum DeploymentUnlockedStateNone = 0 + fromEnum DeploymentUnlockedStateDevelopment = 1 + fromEnum DeploymentUnlockedStateHotfix = 2 + fromEnum (AnotherDeploymentUnlockedState k) = k + + toEnum 0 = DeploymentUnlockedStateNone + toEnum 1 = DeploymentUnlockedStateDevelopment + toEnum 2 = DeploymentUnlockedStateHotfix + toEnum k = AnotherDeploymentUnlockedState k + +instance P.Ord DeploymentUnlockedState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + + diff --git a/GI/OSTree/Enums.hs-boot b/GI/OSTree/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Enums.hs-boot @@ -0,0 +1,52 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Enums 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.ManagedPtr as B.ManagedPtr +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.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 + +data StaticDeltaGenerateOpt +instance P.Enum StaticDeltaGenerateOpt where +data RepoRemoteChange +instance P.Enum RepoRemoteChange where +data RepoPruneFlags +instance P.Enum RepoPruneFlags where +data RepoMode +instance P.Enum RepoMode where +data RepoCommitIterResult +instance P.Enum RepoCommitIterResult where +data RepoCommitFilterResult +instance P.Enum RepoCommitFilterResult where +data RepoCheckoutOverwriteMode +instance P.Enum RepoCheckoutOverwriteMode where +data RepoCheckoutMode +instance P.Enum RepoCheckoutMode where +data RepoCheckoutFilterResult +instance P.Enum RepoCheckoutFilterResult where +data ObjectType +instance P.Enum ObjectType where +data GpgSignatureFormatFlags +instance P.Enum GpgSignatureFormatFlags where +data GpgSignatureAttr +instance P.Enum GpgSignatureAttr where +data GpgError +instance P.Enum GpgError where +data DeploymentUnlockedState +instance P.Enum DeploymentUnlockedState where diff --git a/GI/OSTree/Flags.hs b/GI/OSTree/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Flags.hs @@ -0,0 +1,624 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Flags + ( + + -- * Flags +-- ** ChecksumFlags #flag:ChecksumFlags# + + ChecksumFlags(..) , + + +-- ** DiffFlags #flag:DiffFlags# + + DiffFlags(..) , + + +-- ** RepoCommitModifierFlags #flag:RepoCommitModifierFlags# + + RepoCommitModifierFlags(..) , + + +-- ** RepoCommitState #flag:RepoCommitState# + + RepoCommitState(..) , + + +-- ** RepoCommitTraverseFlags #flag:RepoCommitTraverseFlags# + + RepoCommitTraverseFlags(..) , + + +-- ** RepoListObjectsFlags #flag:RepoListObjectsFlags# + + RepoListObjectsFlags(..) , + + +-- ** RepoListRefsExtFlags #flag:RepoListRefsExtFlags# + + RepoListRefsExtFlags(..) , + + +-- ** RepoPullFlags #flag:RepoPullFlags# + + RepoPullFlags(..) , + + +-- ** RepoResolveRevExtFlags #flag:RepoResolveRevExtFlags# + + RepoResolveRevExtFlags(..) , + + +-- ** SePolicyRestoreconFlags #flag:SePolicyRestoreconFlags# + + SePolicyRestoreconFlags(..) , + + +-- ** SysrootSimpleWriteDeploymentFlags #flag:SysrootSimpleWriteDeploymentFlags# + + SysrootSimpleWriteDeploymentFlags(..) , + + +-- ** SysrootUpgraderFlags #flag:SysrootUpgraderFlags# + + SysrootUpgraderFlags(..) , + + +-- ** SysrootUpgraderPullFlags #flag:SysrootUpgraderPullFlags# + + SysrootUpgraderPullFlags(..) , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- Flags SysrootUpgraderPullFlags +{- | +/No description available in the introspection data./ +-} +data SysrootUpgraderPullFlags = + SysrootUpgraderPullFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | SysrootUpgraderPullFlagsAllowOlder + {- ^ + /No description available in the introspection data./ + -} + | SysrootUpgraderPullFlagsSynthetic + {- ^ + /No description available in the introspection data./ + -} + | AnotherSysrootUpgraderPullFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SysrootUpgraderPullFlags where + fromEnum SysrootUpgraderPullFlagsNone = 0 + fromEnum SysrootUpgraderPullFlagsAllowOlder = 1 + fromEnum SysrootUpgraderPullFlagsSynthetic = 2 + fromEnum (AnotherSysrootUpgraderPullFlags k) = k + + toEnum 0 = SysrootUpgraderPullFlagsNone + toEnum 1 = SysrootUpgraderPullFlagsAllowOlder + toEnum 2 = SysrootUpgraderPullFlagsSynthetic + toEnum k = AnotherSysrootUpgraderPullFlags k + +instance P.Ord SysrootUpgraderPullFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag SysrootUpgraderPullFlags + +-- Flags SysrootUpgraderFlags +{- | +Flags controlling operation of an 'GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader'. +-} +data SysrootUpgraderFlags = + SysrootUpgraderFlagsIgnoreUnconfigured + {- ^ + Do not error if the origin has an unconfigured-state key + -} + | AnotherSysrootUpgraderFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SysrootUpgraderFlags where + fromEnum SysrootUpgraderFlagsIgnoreUnconfigured = 2 + fromEnum (AnotherSysrootUpgraderFlags k) = k + + toEnum 2 = SysrootUpgraderFlagsIgnoreUnconfigured + toEnum k = AnotherSysrootUpgraderFlags k + +instance P.Ord SysrootUpgraderFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ostree_sysroot_upgrader_flags_get_type" c_ostree_sysroot_upgrader_flags_get_type :: + IO GType + +instance BoxedFlags SysrootUpgraderFlags where + boxedFlagsType _ = c_ostree_sysroot_upgrader_flags_get_type + +instance IsGFlag SysrootUpgraderFlags + +-- Flags SysrootSimpleWriteDeploymentFlags +{- | +/No description available in the introspection data./ +-} +data SysrootSimpleWriteDeploymentFlags = + SysrootSimpleWriteDeploymentFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | SysrootSimpleWriteDeploymentFlagsRetain + {- ^ + /No description available in the introspection data./ + -} + | SysrootSimpleWriteDeploymentFlagsNotDefault + {- ^ + /No description available in the introspection data./ + -} + | SysrootSimpleWriteDeploymentFlagsNoClean + {- ^ + /No description available in the introspection data./ + -} + | SysrootSimpleWriteDeploymentFlagsRetainPending + {- ^ + /No description available in the introspection data./ + -} + | SysrootSimpleWriteDeploymentFlagsRetainRollback + {- ^ + /No description available in the introspection data./ + -} + | AnotherSysrootSimpleWriteDeploymentFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SysrootSimpleWriteDeploymentFlags where + fromEnum SysrootSimpleWriteDeploymentFlagsNone = 0 + fromEnum SysrootSimpleWriteDeploymentFlagsRetain = 1 + fromEnum SysrootSimpleWriteDeploymentFlagsNotDefault = 2 + fromEnum SysrootSimpleWriteDeploymentFlagsNoClean = 4 + fromEnum SysrootSimpleWriteDeploymentFlagsRetainPending = 8 + fromEnum SysrootSimpleWriteDeploymentFlagsRetainRollback = 16 + fromEnum (AnotherSysrootSimpleWriteDeploymentFlags k) = k + + toEnum 0 = SysrootSimpleWriteDeploymentFlagsNone + toEnum 1 = SysrootSimpleWriteDeploymentFlagsRetain + toEnum 2 = SysrootSimpleWriteDeploymentFlagsNotDefault + toEnum 4 = SysrootSimpleWriteDeploymentFlagsNoClean + toEnum 8 = SysrootSimpleWriteDeploymentFlagsRetainPending + toEnum 16 = SysrootSimpleWriteDeploymentFlagsRetainRollback + toEnum k = AnotherSysrootSimpleWriteDeploymentFlags k + +instance P.Ord SysrootSimpleWriteDeploymentFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag SysrootSimpleWriteDeploymentFlags + +-- Flags SePolicyRestoreconFlags +{- | +/No description available in the introspection data./ +-} +data SePolicyRestoreconFlags = + SePolicyRestoreconFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | SePolicyRestoreconFlagsAllowNolabel + {- ^ + /No description available in the introspection data./ + -} + | SePolicyRestoreconFlagsKeepExisting + {- ^ + /No description available in the introspection data./ + -} + | AnotherSePolicyRestoreconFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SePolicyRestoreconFlags where + fromEnum SePolicyRestoreconFlagsNone = 0 + fromEnum SePolicyRestoreconFlagsAllowNolabel = 1 + fromEnum SePolicyRestoreconFlagsKeepExisting = 2 + fromEnum (AnotherSePolicyRestoreconFlags k) = k + + toEnum 0 = SePolicyRestoreconFlagsNone + toEnum 1 = SePolicyRestoreconFlagsAllowNolabel + toEnum 2 = SePolicyRestoreconFlagsKeepExisting + toEnum k = AnotherSePolicyRestoreconFlags k + +instance P.Ord SePolicyRestoreconFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag SePolicyRestoreconFlags + +-- Flags RepoResolveRevExtFlags +{- | +/No description available in the introspection data./ +-} +data RepoResolveRevExtFlags = + RepoResolveRevExtFlagsNone + {- ^ + No flags. + -} + | RepoResolveRevExtFlagsLocalOnly + {- ^ + Exclude remote and mirrored refs. Since: 2019.2 + -} + | AnotherRepoResolveRevExtFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoResolveRevExtFlags where + fromEnum RepoResolveRevExtFlagsNone = 0 + fromEnum RepoResolveRevExtFlagsLocalOnly = 1 + fromEnum (AnotherRepoResolveRevExtFlags k) = k + + toEnum 0 = RepoResolveRevExtFlagsNone + toEnum 1 = RepoResolveRevExtFlagsLocalOnly + toEnum k = AnotherRepoResolveRevExtFlags k + +instance P.Ord RepoResolveRevExtFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoResolveRevExtFlags + +-- Flags RepoPullFlags +{- | +/No description available in the introspection data./ +-} +data RepoPullFlags = + RepoPullFlagsNone + {- ^ + No special options for pull + -} + | RepoPullFlagsMirror + {- ^ + Write out refs suitable for mirrors and fetch all refs if none requested + -} + | RepoPullFlagsCommitOnly + {- ^ + Fetch only the commit metadata + -} + | RepoPullFlagsUntrusted + {- ^ + Do verify checksums of local (filesystem-accessible) repositories (defaults on for HTTP) + -} + | RepoPullFlagsBareuseronlyFiles + {- ^ + Since 2017.7. Reject writes of content objects with modes outside of 0775. + -} + | RepoPullFlagsTrustedHttp + {- ^ + Don\'t verify checksums of objects HTTP repositories (Since: 2017.12) + -} + | AnotherRepoPullFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoPullFlags where + fromEnum RepoPullFlagsNone = 0 + fromEnum RepoPullFlagsMirror = 1 + fromEnum RepoPullFlagsCommitOnly = 2 + fromEnum RepoPullFlagsUntrusted = 4 + fromEnum RepoPullFlagsBareuseronlyFiles = 8 + fromEnum RepoPullFlagsTrustedHttp = 16 + fromEnum (AnotherRepoPullFlags k) = k + + toEnum 0 = RepoPullFlagsNone + toEnum 1 = RepoPullFlagsMirror + toEnum 2 = RepoPullFlagsCommitOnly + toEnum 4 = RepoPullFlagsUntrusted + toEnum 8 = RepoPullFlagsBareuseronlyFiles + toEnum 16 = RepoPullFlagsTrustedHttp + toEnum k = AnotherRepoPullFlags k + +instance P.Ord RepoPullFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoPullFlags + +-- Flags RepoListRefsExtFlags +{- | +/No description available in the introspection data./ +-} +data RepoListRefsExtFlags = + RepoListRefsExtFlagsNone + {- ^ + No flags. + -} + | RepoListRefsExtFlagsAliases + {- ^ + Only list aliases. Since: 2017.10 + -} + | RepoListRefsExtFlagsExcludeRemotes + {- ^ + Exclude remote refs. Since: 2017.11 + -} + | RepoListRefsExtFlagsExcludeMirrors + {- ^ + Exclude mirrored refs. Since: 2019.2 + -} + | AnotherRepoListRefsExtFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoListRefsExtFlags where + fromEnum RepoListRefsExtFlagsNone = 0 + fromEnum RepoListRefsExtFlagsAliases = 1 + fromEnum RepoListRefsExtFlagsExcludeRemotes = 2 + fromEnum RepoListRefsExtFlagsExcludeMirrors = 4 + fromEnum (AnotherRepoListRefsExtFlags k) = k + + toEnum 0 = RepoListRefsExtFlagsNone + toEnum 1 = RepoListRefsExtFlagsAliases + toEnum 2 = RepoListRefsExtFlagsExcludeRemotes + toEnum 4 = RepoListRefsExtFlagsExcludeMirrors + toEnum k = AnotherRepoListRefsExtFlags k + +instance P.Ord RepoListRefsExtFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoListRefsExtFlags + +-- Flags RepoListObjectsFlags +{- | +/No description available in the introspection data./ +-} +data RepoListObjectsFlags = + RepoListObjectsFlagsLoose + {- ^ + List only loose (plain file) objects + -} + | RepoListObjectsFlagsPacked + {- ^ + List only packed (compacted into blobs) objects + -} + | RepoListObjectsFlagsAll + {- ^ + List all objects + -} + | RepoListObjectsFlagsNoParents + {- ^ + Only list objects in this repo, not parents + -} + | AnotherRepoListObjectsFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoListObjectsFlags where + fromEnum RepoListObjectsFlagsLoose = 1 + fromEnum RepoListObjectsFlagsPacked = 2 + fromEnum RepoListObjectsFlagsAll = 4 + fromEnum RepoListObjectsFlagsNoParents = 8 + fromEnum (AnotherRepoListObjectsFlags k) = k + + toEnum 1 = RepoListObjectsFlagsLoose + toEnum 2 = RepoListObjectsFlagsPacked + toEnum 4 = RepoListObjectsFlagsAll + toEnum 8 = RepoListObjectsFlagsNoParents + toEnum k = AnotherRepoListObjectsFlags k + +instance P.Ord RepoListObjectsFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoListObjectsFlags + +-- Flags RepoCommitTraverseFlags +{- | +/No description available in the introspection data./ +-} +data RepoCommitTraverseFlags = + RepoCommitTraverseFlagsRepoCommitTraverseFlagNone + {- ^ + /No description available in the introspection data./ + -} + | AnotherRepoCommitTraverseFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCommitTraverseFlags where + fromEnum RepoCommitTraverseFlagsRepoCommitTraverseFlagNone = 1 + fromEnum (AnotherRepoCommitTraverseFlags k) = k + + toEnum 1 = RepoCommitTraverseFlagsRepoCommitTraverseFlagNone + toEnum k = AnotherRepoCommitTraverseFlags k + +instance P.Ord RepoCommitTraverseFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoCommitTraverseFlags + +-- Flags RepoCommitState +{- | +Flags representing the state of a commit in the local repository, as returned +by 'GI.OSTree.Objects.Repo.repoLoadCommit'. + +/Since: 2015.7/ +-} +data RepoCommitState = + RepoCommitStateNormal + {- ^ + Commit is complete. This is the default. + (Since: 2017.14.) + -} + | RepoCommitStatePartial + {- ^ + One or more objects are missing from the + local copy of the commit, but metadata is present. (Since: 2015.7.) + -} + | AnotherRepoCommitState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCommitState where + fromEnum RepoCommitStateNormal = 0 + fromEnum RepoCommitStatePartial = 1 + fromEnum (AnotherRepoCommitState k) = k + + toEnum 0 = RepoCommitStateNormal + toEnum 1 = RepoCommitStatePartial + toEnum k = AnotherRepoCommitState k + +instance P.Ord RepoCommitState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoCommitState + +-- Flags RepoCommitModifierFlags +{- | +/No description available in the introspection data./ +-} +data RepoCommitModifierFlags = + RepoCommitModifierFlagsNone + {- ^ + No special flags + -} + | RepoCommitModifierFlagsSkipXattrs + {- ^ + Do not process extended attributes + -} + | RepoCommitModifierFlagsGenerateSizes + {- ^ + Generate size information. + -} + | RepoCommitModifierFlagsCanonicalPermissions + {- ^ + Canonicalize permissions for bare-user-only mode. + -} + | RepoCommitModifierFlagsErrorOnUnlabeled + {- ^ + Emit an error if configured SELinux policy does not provide a label + -} + | RepoCommitModifierFlagsConsume + {- ^ + Delete added files\/directories after commit; Since: 2017.13 + -} + | RepoCommitModifierFlagsDevinoCanonical + {- ^ + If a devino cache hit is found, skip modifier filters (non-directories only); Since: 2017.14 + -} + | AnotherRepoCommitModifierFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepoCommitModifierFlags where + fromEnum RepoCommitModifierFlagsNone = 0 + fromEnum RepoCommitModifierFlagsSkipXattrs = 1 + fromEnum RepoCommitModifierFlagsGenerateSizes = 2 + fromEnum RepoCommitModifierFlagsCanonicalPermissions = 4 + fromEnum RepoCommitModifierFlagsErrorOnUnlabeled = 8 + fromEnum RepoCommitModifierFlagsConsume = 16 + fromEnum RepoCommitModifierFlagsDevinoCanonical = 32 + fromEnum (AnotherRepoCommitModifierFlags k) = k + + toEnum 0 = RepoCommitModifierFlagsNone + toEnum 1 = RepoCommitModifierFlagsSkipXattrs + toEnum 2 = RepoCommitModifierFlagsGenerateSizes + toEnum 4 = RepoCommitModifierFlagsCanonicalPermissions + toEnum 8 = RepoCommitModifierFlagsErrorOnUnlabeled + toEnum 16 = RepoCommitModifierFlagsConsume + toEnum 32 = RepoCommitModifierFlagsDevinoCanonical + toEnum k = AnotherRepoCommitModifierFlags k + +instance P.Ord RepoCommitModifierFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepoCommitModifierFlags + +-- Flags DiffFlags +{- | +/No description available in the introspection data./ +-} +data DiffFlags = + DiffFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | DiffFlagsIgnoreXattrs + {- ^ + /No description available in the introspection data./ + -} + | AnotherDiffFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffFlags where + fromEnum DiffFlagsNone = 0 + fromEnum DiffFlagsIgnoreXattrs = 1 + fromEnum (AnotherDiffFlags k) = k + + toEnum 0 = DiffFlagsNone + toEnum 1 = DiffFlagsIgnoreXattrs + toEnum k = AnotherDiffFlags k + +instance P.Ord DiffFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag DiffFlags + +-- Flags ChecksumFlags +{- | +/No description available in the introspection data./ + +/Since: 2017.13/ +-} +data ChecksumFlags = + ChecksumFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | ChecksumFlagsIgnoreXattrs + {- ^ + /No description available in the introspection data./ + -} + | AnotherChecksumFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ChecksumFlags where + fromEnum ChecksumFlagsNone = 0 + fromEnum ChecksumFlagsIgnoreXattrs = 1 + fromEnum (AnotherChecksumFlags k) = k + + toEnum 0 = ChecksumFlagsNone + toEnum 1 = ChecksumFlagsIgnoreXattrs + toEnum k = AnotherChecksumFlags k + +instance P.Ord ChecksumFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag ChecksumFlags + + diff --git a/GI/OSTree/Flags.hs-boot b/GI/OSTree/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Flags.hs-boot @@ -0,0 +1,64 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Flags 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.ManagedPtr as B.ManagedPtr +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.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 + +data SysrootUpgraderPullFlags +instance P.Enum SysrootUpgraderPullFlags where +instance IsGFlag SysrootUpgraderPullFlags +data SysrootUpgraderFlags +instance P.Enum SysrootUpgraderFlags where +instance BoxedFlags SysrootUpgraderFlags where +instance IsGFlag SysrootUpgraderFlags +data SysrootSimpleWriteDeploymentFlags +instance P.Enum SysrootSimpleWriteDeploymentFlags where +instance IsGFlag SysrootSimpleWriteDeploymentFlags +data SePolicyRestoreconFlags +instance P.Enum SePolicyRestoreconFlags where +instance IsGFlag SePolicyRestoreconFlags +data RepoResolveRevExtFlags +instance P.Enum RepoResolveRevExtFlags where +instance IsGFlag RepoResolveRevExtFlags +data RepoPullFlags +instance P.Enum RepoPullFlags where +instance IsGFlag RepoPullFlags +data RepoListRefsExtFlags +instance P.Enum RepoListRefsExtFlags where +instance IsGFlag RepoListRefsExtFlags +data RepoListObjectsFlags +instance P.Enum RepoListObjectsFlags where +instance IsGFlag RepoListObjectsFlags +data RepoCommitTraverseFlags +instance P.Enum RepoCommitTraverseFlags where +instance IsGFlag RepoCommitTraverseFlags +data RepoCommitState +instance P.Enum RepoCommitState where +instance IsGFlag RepoCommitState +data RepoCommitModifierFlags +instance P.Enum RepoCommitModifierFlags where +instance IsGFlag RepoCommitModifierFlags +data DiffFlags +instance P.Enum DiffFlags where +instance IsGFlag DiffFlags +data ChecksumFlags +instance P.Enum ChecksumFlags where +instance IsGFlag ChecksumFlags diff --git a/GI/OSTree/Functions.hs b/GI/OSTree/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Functions.hs @@ -0,0 +1,2456 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Functions + ( + + -- * Methods +-- ** breakHardlink #method:breakHardlink# + + breakHardlink , + + +-- ** checkVersion #method:checkVersion# + + checkVersion , + + +-- ** checksumB64FromBytes #method:checksumB64FromBytes# + + checksumB64FromBytes , + + +-- ** checksumB64ToBytes #method:checksumB64ToBytes# + + checksumB64ToBytes , + + +-- ** checksumBytesPeek #method:checksumBytesPeek# + + checksumBytesPeek , + + +-- ** checksumBytesPeekValidate #method:checksumBytesPeekValidate# + + checksumBytesPeekValidate , + + +-- ** checksumFile #method:checksumFile# + + checksumFile , + + +-- ** checksumFileAsync #method:checksumFileAsync# + + checksumFileAsync , + + +-- ** checksumFileAsyncFinish #method:checksumFileAsyncFinish# + + checksumFileAsyncFinish , + + +-- ** checksumFileAt #method:checksumFileAt# + + checksumFileAt , + + +-- ** checksumFileFromInput #method:checksumFileFromInput# + + checksumFileFromInput , + + +-- ** checksumFromBytes #method:checksumFromBytes# + + checksumFromBytes , + + +-- ** checksumFromBytesV #method:checksumFromBytesV# + + checksumFromBytesV , + + +-- ** checksumInplaceToBytes #method:checksumInplaceToBytes# + + checksumInplaceToBytes , + + +-- ** checksumToBytes #method:checksumToBytes# + + checksumToBytes , + + +-- ** checksumToBytesV #method:checksumToBytesV# + + checksumToBytesV , + + +-- ** cmd_Private__ #method:cmd_Private__# + + cmd_Private__ , + + +-- ** cmpChecksumBytes #method:cmpChecksumBytes# + + cmpChecksumBytes , + + +-- ** commitGetContentChecksum #method:commitGetContentChecksum# + + commitGetContentChecksum , + + +-- ** commitGetParent #method:commitGetParent# + + commitGetParent , + + +-- ** commitGetTimestamp #method:commitGetTimestamp# + + commitGetTimestamp , + + +-- ** contentFileParse #method:contentFileParse# + + contentFileParse , + + +-- ** contentFileParseAt #method:contentFileParseAt# + + contentFileParseAt , + + +-- ** contentStreamParse #method:contentStreamParse# + + contentStreamParse , + + +-- ** createDirectoryMetadata #method:createDirectoryMetadata# + + createDirectoryMetadata , + + +-- ** diffDirs #method:diffDirs# + + diffDirs , + + +-- ** diffDirsWithOptions #method:diffDirsWithOptions# + + diffDirsWithOptions , + + +-- ** diffPrint #method:diffPrint# + + diffPrint , + + +-- ** gpgErrorQuark #method:gpgErrorQuark# + + gpgErrorQuark , + + +-- ** hashObjectName #method:hashObjectName# + + hashObjectName , + + +-- ** metadataVariantType #method:metadataVariantType# + + metadataVariantType , + + +-- ** objectFromString #method:objectFromString# + + objectFromString , + + +-- ** objectNameDeserialize #method:objectNameDeserialize# + + objectNameDeserialize , + + +-- ** objectNameSerialize #method:objectNameSerialize# + + objectNameSerialize , + + +-- ** objectToString #method:objectToString# + + objectToString , + + +-- ** objectTypeFromString #method:objectTypeFromString# + + objectTypeFromString , + + +-- ** objectTypeToString #method:objectTypeToString# + + objectTypeToString , + + +-- ** parseRefspec #method:parseRefspec# + + parseRefspec , + + +-- ** rawFileToArchiveZ2Stream #method:rawFileToArchiveZ2Stream# + + rawFileToArchiveZ2Stream , + + +-- ** rawFileToArchiveZ2StreamWithOptions #method:rawFileToArchiveZ2StreamWithOptions# + + rawFileToArchiveZ2StreamWithOptions , + + +-- ** rawFileToContentStream #method:rawFileToContentStream# + + rawFileToContentStream , + + +-- ** validateChecksumString #method:validateChecksumString# + + validateChecksumString , + + +-- ** validateCollectionId #method:validateCollectionId# + + validateCollectionId , + + +-- ** validateRemoteName #method:validateRemoteName# + + validateRemoteName , + + +-- ** validateRev #method:validateRev# + + validateRev , + + +-- ** validateStructureofChecksumString #method:validateStructureofChecksumString# + + validateStructureofChecksumString , + + +-- ** validateStructureofCommit #method:validateStructureofCommit# + + validateStructureofCommit , + + +-- ** validateStructureofCsumV #method:validateStructureofCsumV# + + validateStructureofCsumV , + + +-- ** validateStructureofDirmeta #method:validateStructureofDirmeta# + + validateStructureofDirmeta , + + +-- ** validateStructureofDirtree #method:validateStructureofDirtree# + + validateStructureofDirtree , + + +-- ** validateStructureofFileMode #method:validateStructureofFileMode# + + validateStructureofFileMode , + + +-- ** validateStructureofObjtype #method:validateStructureofObjtype# + + validateStructureofObjtype , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.VariantType as GLib.VariantType +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo +import qualified GI.Gio.Objects.InputStream as Gio.InputStream +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Structs.CmdPrivateVTable as OSTree.CmdPrivateVTable +import {-# SOURCE #-} qualified GI.OSTree.Structs.DiffDirsOptions as OSTree.DiffDirsOptions +import {-# SOURCE #-} qualified GI.OSTree.Structs.DiffItem as OSTree.DiffItem + +-- function ostree_validate_structureof_objtype +-- Args : [Arg {argCName = "objtype", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_objtype" ostree_validate_structureof_objtype :: + Word8 -> -- objtype : TBasicType TUInt8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +validateStructureofObjtype :: + (B.CallStack.HasCallStack, MonadIO m) => + Word8 + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofObjtype objtype = liftIO $ do + onException (do + _ <- propagateGError $ ostree_validate_structureof_objtype objtype + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_file_mode +-- Args : [Arg {argCName = "mode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A Unix filesystem mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_file_mode" ostree_validate_structureof_file_mode :: + Word32 -> -- mode : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +validateStructureofFileMode :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@mode@/: A Unix filesystem mode -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofFileMode mode = liftIO $ do + onException (do + _ <- propagateGError $ ostree_validate_structureof_file_mode mode + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_dirtree +-- Args : [Arg {argCName = "dirtree", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A dirtree object, %OSTREE_OBJECT_TYPE_DIR_TREE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_dirtree" ostree_validate_structureof_dirtree :: + Ptr GVariant -> -- dirtree : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Use this to validate the basic structure of /@dirtree@/, independent of +any other objects it references. +-} +validateStructureofDirtree :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@dirtree@/: A dirtree object, 'GI.OSTree.Enums.ObjectTypeDirTree' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofDirtree dirtree = liftIO $ do + dirtree' <- unsafeManagedPtrGetPtr dirtree + onException (do + _ <- propagateGError $ ostree_validate_structureof_dirtree dirtree' + touchManagedPtr dirtree + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_dirmeta +-- Args : [Arg {argCName = "dirmeta", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A dirmeta object, %OSTREE_OBJECT_TYPE_DIR_META", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_dirmeta" ostree_validate_structureof_dirmeta :: + Ptr GVariant -> -- dirmeta : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Use this to validate the basic structure of /@dirmeta@/. +-} +validateStructureofDirmeta :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@dirmeta@/: A dirmeta object, 'GI.OSTree.Enums.ObjectTypeDirMeta' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofDirmeta dirmeta = liftIO $ do + dirmeta' <- unsafeManagedPtrGetPtr dirmeta + onException (do + _ <- propagateGError $ ostree_validate_structureof_dirmeta dirmeta' + touchManagedPtr dirmeta + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_csum_v +-- Args : [Arg {argCName = "checksum", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVariant of type \"ay\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_csum_v" ostree_validate_structureof_csum_v :: + Ptr GVariant -> -- checksum : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +validateStructureofCsumV :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@checksum@/: a 'GVariant' of type \"ay\" -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofCsumV checksum = liftIO $ do + checksum' <- unsafeManagedPtrGetPtr checksum + onException (do + _ <- propagateGError $ ostree_validate_structureof_csum_v checksum' + touchManagedPtr checksum + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_commit +-- Args : [Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A commit object, %OSTREE_OBJECT_TYPE_COMMIT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_commit" ostree_validate_structureof_commit :: + Ptr GVariant -> -- commit : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Use this to validate the basic structure of /@commit@/, independent of +any other objects it references. +-} +validateStructureofCommit :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@commit@/: A commit object, 'GI.OSTree.Enums.ObjectTypeCommit' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofCommit commit = liftIO $ do + commit' <- unsafeManagedPtrGetPtr commit + onException (do + _ <- propagateGError $ ostree_validate_structureof_commit commit' + touchManagedPtr commit + return () + ) (do + return () + ) + + +-- function ostree_validate_structureof_checksum_string +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an ASCII string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_structureof_checksum_string" ostree_validate_structureof_checksum_string :: + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +validateStructureofChecksumString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: an ASCII string -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateStructureofChecksumString checksum = liftIO $ do + checksum' <- textToCString checksum + onException (do + _ <- propagateGError $ ostree_validate_structureof_checksum_string checksum' + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + + +-- function ostree_validate_rev +-- Args : [Arg {argCName = "rev", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A revision string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_rev" ostree_validate_rev :: + CString -> -- rev : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +validateRev :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@rev@/: A revision string -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateRev rev = liftIO $ do + rev' <- textToCString rev + onException (do + _ <- propagateGError $ ostree_validate_rev rev' + freeMem rev' + return () + ) (do + freeMem rev' + ) + + +-- function ostree_validate_remote_name +-- Args : [Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A remote name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_remote_name" ostree_validate_remote_name :: + CString -> -- remote_name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 2017.8/ +-} +validateRemoteName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@remoteName@/: A remote name -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateRemoteName remoteName = liftIO $ do + remoteName' <- textToCString remoteName + onException (do + _ <- propagateGError $ ostree_validate_remote_name remoteName' + freeMem remoteName' + return () + ) (do + freeMem remoteName' + ) + + +-- function ostree_validate_collection_id +-- Args : [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A collection ID", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_collection_id" ostree_validate_collection_id :: + CString -> -- collection_id : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check whether the given /@collectionId@/ is valid. Return an error if it is +invalid or 'Nothing'. + +Valid collection IDs are reverse DNS names: + * They are composed of 1 or more elements separated by a period (@.@) character. + All elements must contain at least one character. + * Each element must only contain the ASCII characters @[A-Z][a-z][0-9]_@ and must not + begin with a digit. + * They must contain at least one @.@ (period) character (and thus at least two elements). + * They must not begin with a @.@ (period) character. + * They must not exceed 255 characters in length. + +(This makes their format identical to D-Bus interface names, for consistency.) + +/Since: 2018.6/ +-} +validateCollectionId :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@collectionId@/: A collection ID -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateCollectionId collectionId = liftIO $ do + maybeCollectionId <- case collectionId of + Nothing -> return nullPtr + Just jCollectionId -> do + jCollectionId' <- textToCString jCollectionId + return jCollectionId' + onException (do + _ <- propagateGError $ ostree_validate_collection_id maybeCollectionId + freeMem maybeCollectionId + return () + ) (do + freeMem maybeCollectionId + ) + + +-- function ostree_validate_checksum_string +-- Args : [Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "SHA256 hex string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_validate_checksum_string" ostree_validate_checksum_string :: + CString -> -- sha256 : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Use this function to see if input strings are checksums. +-} +validateChecksumString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@sha256@/: SHA256 hex string -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +validateChecksumString sha256 = liftIO $ do + sha256' <- textToCString sha256 + onException (do + _ <- propagateGError $ ostree_validate_checksum_string sha256' + freeMem sha256' + return () + ) (do + freeMem sha256' + ) + + +-- function ostree_raw_file_to_content_stream +-- Args : [Arg {argCName = "input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File raw content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A file info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Serialized object stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_raw_file_to_content_stream" ostree_raw_file_to_content_stream :: + Ptr Gio.InputStream.InputStream -> -- input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Gio.FileInfo.FileInfo -> -- file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr GVariant -> -- xattrs : TVariant + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Word64 -> -- out_length : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Convert from a \"bare\" file representation into an +OSTREE_OBJECT_TYPE_FILE stream. This is a fundamental operation +for writing data to an 'GI.OSTree.Objects.Repo.Repo'. +-} +rawFileToContentStream :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@input@/: File raw content stream -} + -> b + {- ^ /@fileInfo@/: A file info -} + -> Maybe (GVariant) + {- ^ /@xattrs@/: Optional extended attributes -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.InputStream.InputStream, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +rawFileToContentStream input fileInfo xattrs cancellable = liftIO $ do + input' <- unsafeManagedPtrCastPtr input + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + maybeXattrs <- case xattrs of + Nothing -> return nullPtr + Just jXattrs -> do + jXattrs' <- unsafeManagedPtrGetPtr jXattrs + return jXattrs' + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outLength <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_raw_file_to_content_stream input' fileInfo' maybeXattrs outInput outLength maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + outLength' <- peek outLength + touchManagedPtr input + touchManagedPtr fileInfo + whenJust xattrs touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem outInput + freeMem outLength + return (outInput'', outLength') + ) (do + freeMem outInput + freeMem outLength + ) + + +-- function ostree_raw_file_to_archive_z2_stream_with_options +-- Args : [Arg {argCName = "input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File raw content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A file info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A GVariant `a{sv}` with an extensible set of flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Serialized object stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_raw_file_to_archive_z2_stream_with_options" ostree_raw_file_to_archive_z2_stream_with_options :: + Ptr Gio.InputStream.InputStream -> -- input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Gio.FileInfo.FileInfo -> -- file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr GVariant -> -- xattrs : TVariant + Ptr GVariant -> -- options : TVariant + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Functions.rawFileToArchiveZ2Stream', but supports an extensible set +of flags. The following flags are currently defined: + +* @compression-level@ (@i@): Level of compression to use, 0–9, with 0 being +the least compression, and \<0 giving the default level (currently 6). + + +/Since: 2017.3/ +-} +rawFileToArchiveZ2StreamWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@input@/: File raw content stream -} + -> b + {- ^ /@fileInfo@/: A file info -} + -> Maybe (GVariant) + {- ^ /@xattrs@/: Optional extended attributes -} + -> Maybe (GVariant) + {- ^ /@options@/: A GVariant @a{sv}@ with an extensible set of flags -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (Gio.InputStream.InputStream) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +rawFileToArchiveZ2StreamWithOptions input fileInfo xattrs options cancellable = liftIO $ do + input' <- unsafeManagedPtrCastPtr input + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + maybeXattrs <- case xattrs of + Nothing -> return nullPtr + Just jXattrs -> do + jXattrs' <- unsafeManagedPtrGetPtr jXattrs + return jXattrs' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_raw_file_to_archive_z2_stream_with_options input' fileInfo' maybeXattrs maybeOptions outInput maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + touchManagedPtr input + touchManagedPtr fileInfo + whenJust xattrs touchManagedPtr + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem outInput + return outInput'' + ) (do + freeMem outInput + ) + + +-- function ostree_raw_file_to_archive_z2_stream +-- Args : [Arg {argCName = "input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File raw content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A file info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Serialized object stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_raw_file_to_archive_z2_stream" ostree_raw_file_to_archive_z2_stream :: + Ptr Gio.InputStream.InputStream -> -- input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Gio.FileInfo.FileInfo -> -- file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr GVariant -> -- xattrs : TVariant + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Convert from a \"bare\" file representation into an +OSTREE_OBJECT_TYPE_FILE stream suitable for ostree pull. +-} +rawFileToArchiveZ2Stream :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@input@/: File raw content stream -} + -> b + {- ^ /@fileInfo@/: A file info -} + -> Maybe (GVariant) + {- ^ /@xattrs@/: Optional extended attributes -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (Gio.InputStream.InputStream) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +rawFileToArchiveZ2Stream input fileInfo xattrs cancellable = liftIO $ do + input' <- unsafeManagedPtrCastPtr input + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + maybeXattrs <- case xattrs of + Nothing -> return nullPtr + Just jXattrs -> do + jXattrs' <- unsafeManagedPtrGetPtr jXattrs + return jXattrs' + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_raw_file_to_archive_z2_stream input' fileInfo' maybeXattrs outInput maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + touchManagedPtr input + touchManagedPtr fileInfo + whenJust xattrs touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem outInput + return outInput'' + ) (do + freeMem outInput + ) + + +-- function ostree_parse_refspec +-- Args : [Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A \"refspec\" string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_remote", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for the remote name,\n or %NULL if the refspec refs to a local ref", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_ref", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the ref name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_parse_refspec" ostree_parse_refspec :: + CString -> -- refspec : TBasicType TUTF8 + Ptr CString -> -- out_remote : TBasicType TUTF8 + Ptr CString -> -- out_ref : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Split a refspec like @gnome-ostree:gnome-ostree\/buildmaster@ or just +@gnome-ostree\/buildmaster@ into two parts. In the first case, /@outRemote@/ +will be set to @gnome-ostree@, and /@outRef@/ to @gnome-ostree\/buildmaster@. +In the second case (a local ref), /@outRemote@/ will be 'Nothing', and /@outRef@/ +will be @gnome-ostree\/buildmaster@. In both cases, 'True' will be returned. +-} +parseRefspec :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@refspec@/: A \"refspec\" string -} + -> m ((Maybe T.Text, T.Text)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +parseRefspec refspec = liftIO $ do + refspec' <- textToCString refspec + outRemote <- allocMem :: IO (Ptr CString) + outRef <- allocMem :: IO (Ptr CString) + onException (do + _ <- propagateGError $ ostree_parse_refspec refspec' outRemote outRef + outRemote' <- peek outRemote + maybeOutRemote' <- convertIfNonNull outRemote' $ \outRemote'' -> do + outRemote''' <- cstringToText outRemote'' + return outRemote''' + freeMem outRemote' + outRef' <- peek outRef + outRef'' <- cstringToText outRef' + freeMem outRef' + freeMem refspec' + freeMem outRemote + freeMem outRef + return (maybeOutRemote', outRef'') + ) (do + freeMem refspec' + freeMem outRemote + freeMem outRef + ) + + +-- function ostree_object_type_to_string +-- Args : [Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeObjectType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_type_to_string" ostree_object_type_to_string :: + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO CString + +{- | +Serialize /@objtype@/ to a string; this is used for file extensions. +-} +objectTypeToString :: + (B.CallStack.HasCallStack, MonadIO m) => + OSTree.Enums.ObjectType + {- ^ /@objtype@/: an 'GI.OSTree.Enums.ObjectType' -} + -> m T.Text +objectTypeToString objtype = liftIO $ do + let objtype' = (fromIntegral . fromEnum) objtype + result <- ostree_object_type_to_string objtype' + checkUnexpectedReturnNULL "objectTypeToString" result + result' <- cstringToText result + return result' + + +-- function ostree_object_type_from_string +-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A stringified version of #OstreeObjectType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "ObjectType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_type_from_string" ostree_object_type_from_string :: + CString -> -- str : TBasicType TUTF8 + IO CUInt + +{- | +The reverse of 'GI.OSTree.Functions.objectTypeToString'. +-} +objectTypeFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@str@/: A stringified version of 'GI.OSTree.Enums.ObjectType' -} + -> m OSTree.Enums.ObjectType +objectTypeFromString str = liftIO $ do + str' <- textToCString str + result <- ostree_object_type_from_string str' + let result' = (toEnum . fromIntegral) result + freeMem str' + return result' + + +-- function ostree_object_to_string +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_to_string" ostree_object_to_string :: + CString -> -- checksum : TBasicType TUTF8 + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +objectToString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: An ASCII checksum -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> m T.Text + {- ^ __Returns:__ A string containing both /@checksum@/ and a stringifed version of /@objtype@/ -} +objectToString checksum objtype = liftIO $ do + checksum' <- textToCString checksum + let objtype' = (fromIntegral . fromEnum) objtype + result <- ostree_object_to_string checksum' objtype' + checkUnexpectedReturnNULL "objectToString" result + result' <- cstringToText result + freeMem result + freeMem checksum' + return result' + + +-- function ostree_object_name_serialize +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_name_serialize" ostree_object_name_serialize :: + CString -> -- checksum : TBasicType TUTF8 + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO (Ptr GVariant) + +{- | +/No description available in the introspection data./ +-} +objectNameSerialize :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: An ASCII checksum -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: An object type -} + -> m GVariant + {- ^ __Returns:__ A new floating 'GVariant' containing checksum string and objtype -} +objectNameSerialize checksum objtype = liftIO $ do + checksum' <- textToCString checksum + let objtype' = (fromIntegral . fromEnum) objtype + result <- ostree_object_name_serialize checksum' objtype' + checkUnexpectedReturnNULL "objectNameSerialize" result + result' <- B.GVariant.newGVariantFromPtr result + freeMem checksum' + return result' + + +-- function ostree_object_name_deserialize +-- Args : [Arg {argCName = "variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GVariant of type (su)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_checksum", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer into string memory of @variant with checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_name_deserialize" ostree_object_name_deserialize :: + Ptr GVariant -> -- variant : TVariant + Ptr CString -> -- out_checksum : TBasicType TUTF8 + Ptr CUInt -> -- out_objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO () + +{- | +Reverse 'GI.OSTree.Functions.objectNameSerialize'. Note that /@outChecksum@/ is +only valid for the lifetime of /@variant@/, and must not be freed. +-} +objectNameDeserialize :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@variant@/: A 'GVariant' of type (su) -} + -> m ((T.Text, OSTree.Enums.ObjectType)) +objectNameDeserialize variant = liftIO $ do + variant' <- unsafeManagedPtrGetPtr variant + outChecksum <- allocMem :: IO (Ptr CString) + outObjtype <- allocMem :: IO (Ptr CUInt) + ostree_object_name_deserialize variant' outChecksum outObjtype + outChecksum' <- peek outChecksum + outChecksum'' <- cstringToText outChecksum' + outObjtype' <- peek outObjtype + let outObjtype'' = (toEnum . fromIntegral) outObjtype' + touchManagedPtr variant + freeMem outChecksum + freeMem outObjtype + return (outChecksum'', outObjtype'') + + +-- function ostree_object_from_string +-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_checksum", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Parsed checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Parsed object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_object_from_string" ostree_object_from_string :: + CString -> -- str : TBasicType TUTF8 + Ptr CString -> -- out_checksum : TBasicType TUTF8 + Ptr CUInt -> -- out_objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO () + +{- | +Reverse 'GI.OSTree.Functions.objectToString'. +-} +objectFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@str@/: An ASCII checksum -} + -> m ((T.Text, OSTree.Enums.ObjectType)) +objectFromString str = liftIO $ do + str' <- textToCString str + outChecksum <- allocMem :: IO (Ptr CString) + outObjtype <- allocMem :: IO (Ptr CUInt) + ostree_object_from_string str' outChecksum outObjtype + outChecksum' <- peek outChecksum + outChecksum'' <- cstringToText outChecksum' + freeMem outChecksum' + outObjtype' <- peek outObjtype + let outObjtype'' = (toEnum . fromIntegral) outObjtype' + freeMem str' + freeMem outChecksum + freeMem outObjtype + return (outChecksum'', outObjtype'') + + +-- function ostree_metadata_variant_type +-- Args : [Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "VariantType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_metadata_variant_type" ostree_metadata_variant_type :: + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + IO (Ptr GLib.VariantType.VariantType) + +{- | +/No description available in the introspection data./ +-} +metadataVariantType :: + (B.CallStack.HasCallStack, MonadIO m) => + OSTree.Enums.ObjectType + -> m GLib.VariantType.VariantType +metadataVariantType objtype = liftIO $ do + let objtype' = (fromIntegral . fromEnum) objtype + result <- ostree_metadata_variant_type objtype' + checkUnexpectedReturnNULL "metadataVariantType" result + result' <- (newBoxed GLib.VariantType.VariantType) result + return result' + + +-- function ostree_hash_object_name +-- Args : [Arg {argCName = "a", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GVariant containing a serialized object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_hash_object_name" ostree_hash_object_name :: + Ptr () -> -- a : TBasicType TPtr + IO Word32 + +{- | +Use this function with 'GI.GLib.Structs.HashTable.HashTable' and 'GI.OSTree.Functions.objectNameSerialize'. +-} +hashObjectName :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + {- ^ /@a@/: A 'GVariant' containing a serialized object -} + -> m Word32 +hashObjectName a = liftIO $ do + result <- ostree_hash_object_name a + return result + + +-- function ostree_gpg_error_quark +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_error_quark" ostree_gpg_error_quark :: + IO Word32 + +{- | +/No description available in the introspection data./ +-} +gpgErrorQuark :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 +gpgErrorQuark = liftIO $ do + result <- ostree_gpg_error_quark + return result + + +-- function ostree_diff_print +-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modified", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Modified files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "removed", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Removed files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "added", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Added files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_diff_print" ostree_diff_print :: + Ptr Gio.File.File -> -- a : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- b : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) -> -- modified : TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- removed : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- added : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + IO () + +{- | +Print the contents of a diff to stdout. +-} +diffPrint :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b) => + a + {- ^ /@a@/: First directory path -} + -> b + {- ^ /@b@/: First directory path -} + -> [OSTree.DiffItem.DiffItem] + {- ^ /@modified@/: Modified files -} + -> [Gio.File.File] + {- ^ /@removed@/: Removed files -} + -> [Gio.File.File] + {- ^ /@added@/: Added files -} + -> m () +diffPrint a b modified removed added = liftIO $ do + a' <- unsafeManagedPtrCastPtr a + b' <- unsafeManagedPtrCastPtr b + modified' <- mapM unsafeManagedPtrGetPtr modified + modified'' <- packGPtrArray modified' + removed' <- mapM unsafeManagedPtrCastPtr removed + removed'' <- packGPtrArray removed' + added' <- mapM unsafeManagedPtrCastPtr added + added'' <- packGPtrArray added' + ostree_diff_print a' b' modified'' removed'' added'' + touchManagedPtr a + touchManagedPtr b + mapM_ touchManagedPtr modified + mapM_ touchManagedPtr removed + mapM_ touchManagedPtr added + unrefPtrArray modified'' + unrefPtrArray removed'' + unrefPtrArray added'' + return () + + +-- function ostree_diff_dirs_with_options +-- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "DiffFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modified", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Modified files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "removed", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Removed files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "added", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Added files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "OSTree", name = "DiffDirsOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_diff_dirs_with_options" ostree_diff_dirs_with_options :: + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "DiffFlags"}) + Ptr Gio.File.File -> -- a : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- b : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) -> -- modified : TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- removed : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- added : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + Ptr OSTree.DiffDirsOptions.DiffDirsOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "DiffDirsOptions"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Compute the difference between directory /@a@/ and /@b@/ as 3 separate +sets of 'GI.OSTree.Structs.DiffItem.DiffItem' in /@modified@/, /@removed@/, and /@added@/. +-} +diffDirsWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + [OSTree.Flags.DiffFlags] + {- ^ /@flags@/: Flags -} + -> a + {- ^ /@a@/: First directory path, or 'Nothing' -} + -> b + {- ^ /@b@/: First directory path -} + -> [OSTree.DiffItem.DiffItem] + {- ^ /@modified@/: Modified files -} + -> [Gio.File.File] + {- ^ /@removed@/: Removed files -} + -> [Gio.File.File] + {- ^ /@added@/: Added files -} + -> Maybe (OSTree.DiffDirsOptions.DiffDirsOptions) + {- ^ /@options@/: Options -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffDirsWithOptions flags a b modified removed added options cancellable = liftIO $ do + let flags' = gflagsToWord flags + a' <- unsafeManagedPtrCastPtr a + b' <- unsafeManagedPtrCastPtr b + modified' <- mapM unsafeManagedPtrGetPtr modified + modified'' <- packGPtrArray modified' + removed' <- mapM unsafeManagedPtrCastPtr removed + removed'' <- packGPtrArray removed' + added' <- mapM unsafeManagedPtrCastPtr added + added'' <- packGPtrArray added' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_diff_dirs_with_options flags' a' b' modified'' removed'' added'' maybeOptions maybeCancellable + touchManagedPtr a + touchManagedPtr b + mapM_ touchManagedPtr modified + mapM_ touchManagedPtr removed + mapM_ touchManagedPtr added + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + unrefPtrArray modified'' + unrefPtrArray removed'' + unrefPtrArray added'' + return () + ) (do + unrefPtrArray modified'' + unrefPtrArray removed'' + unrefPtrArray added'' + ) + + +-- function ostree_diff_dirs +-- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "DiffFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "First directory path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modified", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Modified files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "removed", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Removed files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "added", argType = TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Added files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_diff_dirs" ostree_diff_dirs :: + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "DiffFlags"}) + Ptr Gio.File.File -> -- a : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- b : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) -> -- modified : TPtrArray (TInterface (Name {namespace = "OSTree", name = "DiffItem"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- removed : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + Ptr (GPtrArray (Ptr Gio.File.File)) -> -- added : TPtrArray (TInterface (Name {namespace = "Gio", name = "File"})) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Compute the difference between directory /@a@/ and /@b@/ as 3 separate +sets of 'GI.OSTree.Structs.DiffItem.DiffItem' in /@modified@/, /@removed@/, and /@added@/. +-} +diffDirs :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + [OSTree.Flags.DiffFlags] + {- ^ /@flags@/: Flags -} + -> a + {- ^ /@a@/: First directory path, or 'Nothing' -} + -> b + {- ^ /@b@/: First directory path -} + -> [OSTree.DiffItem.DiffItem] + {- ^ /@modified@/: Modified files -} + -> [Gio.File.File] + {- ^ /@removed@/: Removed files -} + -> [Gio.File.File] + {- ^ /@added@/: Added files -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffDirs flags a b modified removed added cancellable = liftIO $ do + let flags' = gflagsToWord flags + a' <- unsafeManagedPtrCastPtr a + b' <- unsafeManagedPtrCastPtr b + modified' <- mapM unsafeManagedPtrGetPtr modified + modified'' <- packGPtrArray modified' + removed' <- mapM unsafeManagedPtrCastPtr removed + removed'' <- packGPtrArray removed' + added' <- mapM unsafeManagedPtrCastPtr added + added'' <- packGPtrArray added' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_diff_dirs flags' a' b' modified'' removed'' added'' maybeCancellable + touchManagedPtr a + touchManagedPtr b + mapM_ touchManagedPtr modified + mapM_ touchManagedPtr removed + mapM_ touchManagedPtr added + whenJust cancellable touchManagedPtr + unrefPtrArray modified'' + unrefPtrArray removed'' + unrefPtrArray added'' + return () + ) (do + unrefPtrArray modified'' + unrefPtrArray removed'' + unrefPtrArray added'' + ) + + +-- function ostree_create_directory_metadata +-- Args : [Arg {argCName = "dir_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileInfo containing directory information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_create_directory_metadata" ostree_create_directory_metadata :: + Ptr Gio.FileInfo.FileInfo -> -- dir_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr GVariant -> -- xattrs : TVariant + IO (Ptr GVariant) + +{- | +/No description available in the introspection data./ +-} +createDirectoryMetadata :: + (B.CallStack.HasCallStack, MonadIO m, Gio.FileInfo.IsFileInfo a) => + a + {- ^ /@dirInfo@/: a 'GI.Gio.Objects.FileInfo.FileInfo' containing directory information -} + -> Maybe (GVariant) + {- ^ /@xattrs@/: Optional extended attributes -} + -> m GVariant + {- ^ __Returns:__ A new 'GVariant' containing 'GI.OSTree.Enums.ObjectTypeDirMeta' -} +createDirectoryMetadata dirInfo xattrs = liftIO $ do + dirInfo' <- unsafeManagedPtrCastPtr dirInfo + maybeXattrs <- case xattrs of + Nothing -> return nullPtr + Just jXattrs -> do + jXattrs' <- unsafeManagedPtrGetPtr jXattrs + return jXattrs' + result <- ostree_create_directory_metadata dirInfo' maybeXattrs + checkUnexpectedReturnNULL "createDirectoryMetadata" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr dirInfo + whenJust xattrs touchManagedPtr + return result' + + +-- function ostree_content_stream_parse +-- Args : [Arg {argCName = "compressed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the stream is zlib-compressed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "input_length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, assume the content has been validated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The raw file content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Normal metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_xattrs", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_content_stream_parse" ostree_content_stream_parse :: + CInt -> -- compressed : TBasicType TBoolean + Ptr Gio.InputStream.InputStream -> -- input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Word64 -> -- input_length : TBasicType TUInt64 + CInt -> -- trusted : TBasicType TBoolean + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr (Ptr Gio.FileInfo.FileInfo) -> -- out_file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr (Ptr GVariant) -> -- out_xattrs : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +The reverse of 'GI.OSTree.Functions.rawFileToContentStream'; this function +converts an object content stream back into components. +-} +contentStreamParse :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) => + Bool + {- ^ /@compressed@/: Whether or not the stream is zlib-compressed -} + -> a + {- ^ /@input@/: Object content stream -} + -> Word64 + {- ^ /@inputLength@/: Length of stream -} + -> Bool + {- ^ /@trusted@/: If 'True', assume the content has been validated -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +contentStreamParse compressed input inputLength trusted cancellable = liftIO $ do + let compressed' = (fromIntegral . fromEnum) compressed + input' <- unsafeManagedPtrCastPtr input + let trusted' = (fromIntegral . fromEnum) trusted + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outFileInfo <- allocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo)) + outXattrs <- allocMem :: IO (Ptr (Ptr GVariant)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_content_stream_parse compressed' input' inputLength trusted' outInput outFileInfo outXattrs maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + outFileInfo' <- peek outFileInfo + outFileInfo'' <- (wrapObject Gio.FileInfo.FileInfo) outFileInfo' + outXattrs' <- peek outXattrs + outXattrs'' <- B.GVariant.wrapGVariantPtr outXattrs' + touchManagedPtr input + whenJust cancellable touchManagedPtr + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + return (outInput'', outFileInfo'', outXattrs'') + ) (do + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + ) + + +-- function ostree_content_file_parse_at +-- Args : [Arg {argCName = "compressed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the stream is zlib-compressed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory file descriptor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Subpath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, assume the content has been validated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The raw file content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Normal metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_xattrs", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_content_file_parse_at" ostree_content_file_parse_at :: + CInt -> -- compressed : TBasicType TBoolean + Int32 -> -- parent_dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + CInt -> -- trusted : TBasicType TBoolean + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr (Ptr Gio.FileInfo.FileInfo) -> -- out_file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr (Ptr GVariant) -> -- out_xattrs : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +A thin wrapper for 'GI.OSTree.Functions.contentStreamParse'; this function +converts an object content stream back into components. +-} +contentFileParseAt :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Bool + {- ^ /@compressed@/: Whether or not the stream is zlib-compressed -} + -> Int32 + {- ^ /@parentDfd@/: Directory file descriptor -} + -> T.Text + {- ^ /@path@/: Subpath -} + -> Bool + {- ^ /@trusted@/: If 'True', assume the content has been validated -} + -> Maybe (a) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +contentFileParseAt compressed parentDfd path trusted cancellable = liftIO $ do + let compressed' = (fromIntegral . fromEnum) compressed + path' <- textToCString path + let trusted' = (fromIntegral . fromEnum) trusted + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outFileInfo <- allocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo)) + outXattrs <- allocMem :: IO (Ptr (Ptr GVariant)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_content_file_parse_at compressed' parentDfd path' trusted' outInput outFileInfo outXattrs maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + outFileInfo' <- peek outFileInfo + outFileInfo'' <- (wrapObject Gio.FileInfo.FileInfo) outFileInfo' + outXattrs' <- peek outXattrs + outXattrs'' <- B.GVariant.wrapGVariantPtr outXattrs' + whenJust cancellable touchManagedPtr + freeMem path' + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + return (outInput'', outFileInfo'', outXattrs'') + ) (do + freeMem path' + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + ) + + +-- function ostree_content_file_parse +-- Args : [Arg {argCName = "compressed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the stream is zlib-compressed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file containing content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, assume the content has been validated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The raw file content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Normal metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_xattrs", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_content_file_parse" ostree_content_file_parse :: + CInt -> -- compressed : TBasicType TBoolean + Ptr Gio.File.File -> -- content_path : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- trusted : TBasicType TBoolean + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr (Ptr Gio.FileInfo.FileInfo) -> -- out_file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr (Ptr GVariant) -> -- out_xattrs : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +A thin wrapper for 'GI.OSTree.Functions.contentStreamParse'; this function +converts an object content stream back into components. +-} +contentFileParse :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) => + Bool + {- ^ /@compressed@/: Whether or not the stream is zlib-compressed -} + -> a + {- ^ /@contentPath@/: Path to file containing content -} + -> Bool + {- ^ /@trusted@/: If 'True', assume the content has been validated -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +contentFileParse compressed contentPath trusted cancellable = liftIO $ do + let compressed' = (fromIntegral . fromEnum) compressed + contentPath' <- unsafeManagedPtrCastPtr contentPath + let trusted' = (fromIntegral . fromEnum) trusted + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outFileInfo <- allocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo)) + outXattrs <- allocMem :: IO (Ptr (Ptr GVariant)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_content_file_parse compressed' contentPath' trusted' outInput outFileInfo outXattrs maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + outFileInfo' <- peek outFileInfo + outFileInfo'' <- (wrapObject Gio.FileInfo.FileInfo) outFileInfo' + outXattrs' <- peek outXattrs + outXattrs'' <- B.GVariant.wrapGVariantPtr outXattrs' + touchManagedPtr contentPath + whenJust cancellable touchManagedPtr + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + return (outInput'', outFileInfo'', outXattrs'') + ) (do + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + ) + + +-- function ostree_commit_get_timestamp +-- Args : [Arg {argCName = "commit_variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_commit_get_timestamp" ostree_commit_get_timestamp :: + Ptr GVariant -> -- commit_variant : TVariant + IO Word64 + +{- | +/No description available in the introspection data./ +-} +commitGetTimestamp :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + -> m Word64 +commitGetTimestamp commitVariant = liftIO $ do + commitVariant' <- unsafeManagedPtrGetPtr commitVariant + result <- ostree_commit_get_timestamp commitVariant' + touchManagedPtr commitVariant + return result + + +-- function ostree_commit_get_parent +-- Args : [Arg {argCName = "commit_variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Variant of type %OSTREE_OBJECT_TYPE_COMMIT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_commit_get_parent" ostree_commit_get_parent :: + Ptr GVariant -> -- commit_variant : TVariant + IO CString + +{- | +/No description available in the introspection data./ +-} +commitGetParent :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@commitVariant@/: Variant of type 'GI.OSTree.Enums.ObjectTypeCommit' -} + -> m T.Text + {- ^ __Returns:__ Checksum of the parent commit of /@commitVariant@/, or 'Nothing' +if none -} +commitGetParent commitVariant = liftIO $ do + commitVariant' <- unsafeManagedPtrGetPtr commitVariant + result <- ostree_commit_get_parent commitVariant' + checkUnexpectedReturnNULL "commitGetParent" result + result' <- cstringToText result + freeMem result + touchManagedPtr commitVariant + return result' + + +-- function ostree_commit_get_content_checksum +-- Args : [Arg {argCName = "commit_variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A commit object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_commit_get_content_checksum" ostree_commit_get_content_checksum :: + Ptr GVariant -> -- commit_variant : TVariant + IO CString + +{- | +There are use cases where one wants a checksum just of the content of a +commit. OSTree commits by default capture the current timestamp, and may have +additional metadata, which means that re-committing identical content +often results in a new checksum. + +By comparing checksums of content, it\'s possible to easily distinguish +cases where nothing actually changed. + +The content checksums is simply defined as @SHA256(root dirtree_checksum || root_dirmeta_checksum)@, +i.e. the SHA-256 of the root \"dirtree\" object\'s checksum concatenated with the +root \"dirmeta\" checksum (both in binary form, not hexadecimal). +-} +commitGetContentChecksum :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@commitVariant@/: A commit object -} + -> m (Maybe T.Text) + {- ^ __Returns:__ A SHA-256 hex string, or 'Nothing' if /@commitVariant@/ is not well-formed -} +commitGetContentChecksum commitVariant = liftIO $ do + commitVariant' <- unsafeManagedPtrGetPtr commitVariant + result <- ostree_commit_get_content_checksum commitVariant' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr commitVariant + return maybeResult + + +-- function ostree_cmp_checksum_bytes +-- Args : [Arg {argCName = "a", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_cmp_checksum_bytes" ostree_cmp_checksum_bytes :: + Word8 -> -- a : TBasicType TUInt8 + Word8 -> -- b : TBasicType TUInt8 + IO Int32 + +{- | +Compare two binary checksums, using @/memcmp()/@. +-} +cmpChecksumBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + Word8 + {- ^ /@a@/: A binary checksum -} + -> Word8 + {- ^ /@b@/: A binary checksum -} + -> m Int32 +cmpChecksumBytes a b = liftIO $ do + result <- ostree_cmp_checksum_bytes a b + return result + + +-- function ostree_cmd__private__ +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "CmdPrivateVTable"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_cmd__private__" ostree_cmd__private__ :: + IO (Ptr OSTree.CmdPrivateVTable.CmdPrivateVTable) + +{- | +/No description available in the introspection data./ +-} +cmd_Private__ :: + (B.CallStack.HasCallStack, MonadIO m) => + m OSTree.CmdPrivateVTable.CmdPrivateVTable +cmd_Private__ = liftIO $ do + result <- ostree_cmd__private__ + checkUnexpectedReturnNULL "cmd_Private__" result + result' <- (newPtr OSTree.CmdPrivateVTable.CmdPrivateVTable) result + return result' + + +-- function ostree_checksum_to_bytes_v +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_to_bytes_v" ostree_checksum_to_bytes_v :: + CString -> -- checksum : TBasicType TUTF8 + IO (Ptr GVariant) + +{- | +/No description available in the introspection data./ +-} +checksumToBytesV :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: An ASCII checksum -} + -> m GVariant + {- ^ __Returns:__ New 'GVariant' of type ay with length 32 -} +checksumToBytesV checksum = liftIO $ do + checksum' <- textToCString checksum + result <- ostree_checksum_to_bytes_v checksum' + checkUnexpectedReturnNULL "checksumToBytesV" result + result' <- B.GVariant.wrapGVariantPtr result + freeMem checksum' + return result' + + +-- function ostree_checksum_to_bytes +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray False 32 (-1) (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_to_bytes" ostree_checksum_to_bytes :: + CString -> -- checksum : TBasicType TUTF8 + IO (Ptr Word8) + +{- | +/No description available in the introspection data./ +-} +checksumToBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: An ASCII checksum -} + -> m ByteString + {- ^ __Returns:__ Binary checksum from /@checksum@/ of length 32; free with 'GI.GLib.Functions.free'. -} +checksumToBytes checksum = liftIO $ do + checksum' <- textToCString checksum + result <- ostree_checksum_to_bytes checksum' + checkUnexpectedReturnNULL "checksumToBytes" result + result' <- (unpackByteStringWithLength 32) result + freeMem result + freeMem checksum' + return result' + + +-- function ostree_checksum_inplace_to_bytes +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a SHA256 string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Output buffer with at least 32 bytes of space", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_inplace_to_bytes" ostree_checksum_inplace_to_bytes :: + CString -> -- checksum : TBasicType TUTF8 + Word8 -> -- buf : TBasicType TUInt8 + IO () + +{- | +Convert /@checksum@/ from a string to binary in-place, without +allocating memory. Use this function in hot code paths. +-} +checksumInplaceToBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: a SHA256 string -} + -> Word8 + {- ^ /@buf@/: Output buffer with at least 32 bytes of space -} + -> m () +checksumInplaceToBytes checksum buf = liftIO $ do + checksum' <- textToCString checksum + ostree_checksum_inplace_to_bytes checksum' buf + freeMem checksum' + return () + + +-- function ostree_checksum_from_bytes_v +-- Args : [Arg {argCName = "csum_v", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GVariant of type ay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_from_bytes_v" ostree_checksum_from_bytes_v :: + Ptr GVariant -> -- csum_v : TVariant + IO CString + +{- | +/No description available in the introspection data./ +-} +checksumFromBytesV :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@csumV@/: 'GVariant' of type ay -} + -> m T.Text + {- ^ __Returns:__ String form of /@csumBytes@/ -} +checksumFromBytesV csumV = liftIO $ do + csumV' <- unsafeManagedPtrGetPtr csumV + result <- ostree_checksum_from_bytes_v csumV' + checkUnexpectedReturnNULL "checksumFromBytesV" result + result' <- cstringToText result + freeMem result + touchManagedPtr csumV + return result' + + +-- function ostree_checksum_from_bytes +-- Args : [Arg {argCName = "csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An binary checksum of length 32", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_from_bytes" ostree_checksum_from_bytes :: + Ptr Word8 -> -- csum : TCArray False 32 (-1) (TBasicType TUInt8) + IO CString + +{- | +/No description available in the introspection data./ +-} +checksumFromBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + ByteString + {- ^ /@csum@/: An binary checksum of length 32 -} + -> m T.Text + {- ^ __Returns:__ String form of /@csum@/ -} +checksumFromBytes csum = liftIO $ do + csum' <- packByteString csum + result <- ostree_checksum_from_bytes csum' + checkUnexpectedReturnNULL "checksumFromBytes" result + result' <- cstringToText result + freeMem result + freeMem csum' + return result' + + +-- function ostree_checksum_file_from_input +-- Args : [Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File content, should be %NULL for symbolic links", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_checksum_file_from_input" ostree_checksum_file_from_input :: + Ptr Gio.FileInfo.FileInfo -> -- file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr GVariant -> -- xattrs : TVariant + Ptr Gio.InputStream.InputStream -> -- in : TInterface (Name {namespace = "Gio", name = "InputStream"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Compute the OSTree checksum for a given input. +-} +checksumFileFromInput :: + (B.CallStack.HasCallStack, MonadIO m, Gio.FileInfo.IsFileInfo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@fileInfo@/: File information -} + -> Maybe (GVariant) + {- ^ /@xattrs@/: Optional extended attributes -} + -> Maybe (b) + {- ^ /@in@/: File content, should be 'Nothing' for symbolic links -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +checksumFileFromInput fileInfo xattrs in_ objtype cancellable = liftIO $ do + fileInfo' <- unsafeManagedPtrCastPtr fileInfo + maybeXattrs <- case xattrs of + Nothing -> return nullPtr + Just jXattrs -> do + jXattrs' <- unsafeManagedPtrGetPtr jXattrs + return jXattrs' + maybeIn_ <- case in_ of + Nothing -> return nullPtr + Just jIn_ -> do + jIn_' <- unsafeManagedPtrCastPtr jIn_ + return jIn_' + let objtype' = (fromIntegral . fromEnum) objtype + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_checksum_file_from_input fileInfo' maybeXattrs maybeIn_ objtype' outCsum maybeCancellable + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr fileInfo + whenJust xattrs touchManagedPtr + whenJust in_ touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem outCsum + return outCsum'' + ) (do + freeMem outCsum + ) + + +-- function ostree_checksum_file_at +-- Args : [Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory file descriptor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Subpath\n@stbuf (allow-none): Optional stat buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "ChecksumFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags\n@out_checksum (out) (transfer full): Return location for hex checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_checksum_file_at" ostree_checksum_file_at :: + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr () -> -- stbuf : TBasicType TPtr + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "ChecksumFlags"}) + CString -> -- out_checksum : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Compute the OSTree checksum for a given file. This is an fd-relative version +of 'GI.OSTree.Functions.checksumFile' which also takes flags and fills in a caller +allocated buffer. + +/Since: 2017.13/ +-} +checksumFileAt :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Int32 + {- ^ /@dfd@/: Directory file descriptor -} + -> T.Text + {- ^ /@path@/: Subpath +/@stbuf@/ (allow-none): Optional stat buffer -} + -> Ptr () + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> [OSTree.Flags.ChecksumFlags] + {- ^ /@flags@/: Flags +/@outChecksum@/ (out) (transfer full): Return location for hex checksum -} + -> T.Text + -> Maybe (a) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +checksumFileAt dfd path stbuf objtype flags outChecksum cancellable = liftIO $ do + path' <- textToCString path + let objtype' = (fromIntegral . fromEnum) objtype + let flags' = gflagsToWord flags + outChecksum' <- textToCString outChecksum + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_checksum_file_at dfd path' stbuf objtype' flags' outChecksum' maybeCancellable + whenJust cancellable touchManagedPtr + freeMem path' + freeMem outChecksum' + return () + ) (do + freeMem path' + freeMem outChecksum' + ) + + +-- function ostree_checksum_file_async_finish +-- Args : [Arg {argCName = "f", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Async result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_checksum_file_async_finish" ostree_checksum_file_async_finish :: + Ptr Gio.File.File -> -- f : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish computing the OSTree checksum for a given file; see +'GI.OSTree.Functions.checksumFileAsync'. +-} +checksumFileAsyncFinish :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@f@/: File path -} + -> b + {- ^ /@result@/: Async result -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +checksumFileAsyncFinish f result_ = liftIO $ do + f' <- unsafeManagedPtrCastPtr f + result_' <- unsafeManagedPtrCastPtr result_ + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + onException (do + _ <- propagateGError $ ostree_checksum_file_async_finish f' result_' outCsum + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr f + touchManagedPtr result_ + freeMem outCsum + return outCsum'' + ) (do + freeMem outCsum + ) + + +-- function ostree_checksum_file_async +-- Args : [Arg {argCName = "f", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Priority for operation, see %G_IO_PRIORITY_DEFAULT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Invoked when operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_file_async" ostree_checksum_file_async :: + Ptr Gio.File.File -> -- f : TInterface (Name {namespace = "Gio", name = "File"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + Int32 -> -- io_priority : TBasicType TInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Asynchronously compute the OSTree checksum for a given file; +complete with 'GI.OSTree.Functions.checksumFileAsyncFinish'. +-} +checksumFileAsync :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@f@/: File path -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> Int32 + {- ^ /@ioPriority@/: Priority for operation, see @/G_IO_PRIORITY_DEFAULT/@ -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: Invoked when operation is complete -} + -> m () +checksumFileAsync f objtype ioPriority cancellable callback = liftIO $ do + f' <- unsafeManagedPtrCastPtr f + let objtype' = (fromIntegral . fromEnum) objtype + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_checksum_file_async f' objtype' ioPriority maybeCancellable maybeCallback userData + touchManagedPtr f + whenJust cancellable touchManagedPtr + return () + + +-- function ostree_checksum_file +-- Args : [Arg {argCName = "f", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_checksum_file" ostree_checksum_file :: + Ptr Gio.File.File -> -- f : TInterface (Name {namespace = "Gio", name = "File"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Compute the OSTree checksum for a given file. +-} +checksumFile :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@f@/: File path -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +checksumFile f objtype cancellable = liftIO $ do + f' <- unsafeManagedPtrCastPtr f + let objtype' = (fromIntegral . fromEnum) objtype + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_checksum_file f' objtype' outCsum maybeCancellable + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr f + whenJust cancellable touchManagedPtr + freeMem outCsum + return outCsum'' + ) (do + freeMem outCsum + ) + + +-- function ostree_checksum_bytes_peek_validate +-- Args : [Arg {argCName = "bytes", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GVariant of type ay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray False 32 (-1) (TBasicType TUInt8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_checksum_bytes_peek_validate" ostree_checksum_bytes_peek_validate :: + Ptr GVariant -> -- bytes : TVariant + Ptr (Ptr GError) -> -- error + IO (Ptr Word8) + +{- | +Like 'GI.OSTree.Functions.checksumBytesPeek', but also throws /@error@/. +-} +checksumBytesPeekValidate :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@bytes@/: 'GVariant' of type ay -} + -> m ByteString + {- ^ __Returns:__ Binary checksum data /(Can throw 'Data.GI.Base.GError.GError')/ -} +checksumBytesPeekValidate bytes = liftIO $ do + bytes' <- unsafeManagedPtrGetPtr bytes + onException (do + result <- propagateGError $ ostree_checksum_bytes_peek_validate bytes' + checkUnexpectedReturnNULL "checksumBytesPeekValidate" result + result' <- (unpackByteStringWithLength 32) result + touchManagedPtr bytes + return result' + ) (do + return () + ) + + +-- function ostree_checksum_bytes_peek +-- Args : [Arg {argCName = "bytes", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GVariant of type ay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray False 32 (-1) (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_bytes_peek" ostree_checksum_bytes_peek :: + Ptr GVariant -> -- bytes : TVariant + IO (Ptr Word8) + +{- | +/No description available in the introspection data./ +-} +checksumBytesPeek :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@bytes@/: 'GVariant' of type ay -} + -> m ByteString + {- ^ __Returns:__ Binary checksum data in /@bytes@/; do not free. If /@bytes@/ does not have the correct length, return 'Nothing'. -} +checksumBytesPeek bytes = liftIO $ do + bytes' <- unsafeManagedPtrGetPtr bytes + result <- ostree_checksum_bytes_peek bytes' + checkUnexpectedReturnNULL "checksumBytesPeek" result + result' <- (unpackByteStringWithLength 32) result + touchManagedPtr bytes + return result' + + +-- function ostree_checksum_b64_to_bytes +-- Args : [Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray False 32 (-1) (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_b64_to_bytes" ostree_checksum_b64_to_bytes :: + CString -> -- checksum : TBasicType TUTF8 + IO (Ptr Word8) + +{- | +/No description available in the introspection data./ +-} +checksumB64ToBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@checksum@/: An ASCII checksum -} + -> m ByteString + {- ^ __Returns:__ Binary version of /@checksum@/. -} +checksumB64ToBytes checksum = liftIO $ do + checksum' <- textToCString checksum + result <- ostree_checksum_b64_to_bytes checksum' + checkUnexpectedReturnNULL "checksumB64ToBytes" result + result' <- (unpackByteStringWithLength 32) result + freeMem result + freeMem checksum' + return result' + + +-- function ostree_checksum_b64_from_bytes +-- Args : [Arg {argCName = "csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An binary checksum of length 32", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_b64_from_bytes" ostree_checksum_b64_from_bytes :: + Ptr Word8 -> -- csum : TCArray False 32 (-1) (TBasicType TUInt8) + IO CString + +{- | +/No description available in the introspection data./ +-} +checksumB64FromBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + ByteString + {- ^ /@csum@/: An binary checksum of length 32 -} + -> m T.Text + {- ^ __Returns:__ Modified base64 encoding of /@csum@/ + +The \"modified\" term refers to the fact that instead of \'\/\', the \'_\' +character is used. -} +checksumB64FromBytes csum = liftIO $ do + csum' <- packByteString csum + result <- ostree_checksum_b64_from_bytes csum' + checkUnexpectedReturnNULL "checksumB64FromBytes" result + result' <- cstringToText result + freeMem result + freeMem csum' + return result' + + +-- function ostree_check_version +-- Args : [Arg {argCName = "required_year", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Major/year required", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "required_release", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Release version required", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_check_version" ostree_check_version :: + Word32 -> -- required_year : TBasicType TUInt + Word32 -> -- required_release : TBasicType TUInt + IO CInt + +{- | +/No description available in the introspection data./ +-} +checkVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@requiredYear@/: Major\/year required -} + -> Word32 + {- ^ /@requiredRelease@/: Release version required -} + -> m Bool + {- ^ __Returns:__ 'True' if current libostree has at least the requested version, 'False' otherwise -} +checkVersion requiredYear requiredRelease = liftIO $ do + result <- ostree_check_version requiredYear requiredRelease + let result' = (/= 0) result + return result' + + +-- function ostree_break_hardlink +-- Args : [Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory fd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path relative to @dfd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip_xattrs", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Do not copy extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_break_hardlink" ostree_break_hardlink :: + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + CInt -> -- skip_xattrs : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +In many cases using libostree, a program may need to \"break\" +hardlinks by performing a copy. For example, in order to +logically append to a file. + +This function performs full copying, including e.g. extended +attributes and permissions of both regular files and symbolic links. + +If the file is not hardlinked, this function does nothing and +returns successfully. + +This function does not perform synchronization via @fsync()@ or +@fdatasync()@; the idea is this will commonly be done as part +of an @ostree_repo_commit_transaction()@, which itself takes +care of synchronization. + +/Since: 2017.15/ +-} +breakHardlink :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Int32 + {- ^ /@dfd@/: Directory fd -} + -> T.Text + {- ^ /@path@/: Path relative to /@dfd@/ -} + -> Bool + {- ^ /@skipXattrs@/: Do not copy extended attributes -} + -> Maybe (a) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +breakHardlink dfd path skipXattrs cancellable = liftIO $ do + path' <- textToCString path + let skipXattrs' = (fromIntegral . fromEnum) skipXattrs + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_break_hardlink dfd path' skipXattrs' maybeCancellable + whenJust cancellable touchManagedPtr + freeMem path' + return () + ) (do + freeMem path' + ) + + + diff --git a/GI/OSTree/Interfaces.hs b/GI/OSTree/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Interfaces.hs @@ -0,0 +1,41 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Interfaces + ( module GI.OSTree.Interfaces.RepoFinder , + + + ) where + +import GI.OSTree.Interfaces.RepoFinder + +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.ManagedPtr as B.ManagedPtr +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.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 + + + diff --git a/GI/OSTree/Interfaces/RepoFinder.hs b/GI/OSTree/Interfaces/RepoFinder.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Interfaces/RepoFinder.hs @@ -0,0 +1,410 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Interfaces.RepoFinder + ( + +-- * Exported types + RepoFinder(..) , + noRepoFinder , + IsRepoFinder , + toRepoFinder , + + + -- * Methods +-- ** resolveAllAsync #method:resolveAllAsync# + + repoFinderResolveAllAsync , + + +-- ** resolveAllFinish #method:resolveAllFinish# + + repoFinderResolveAllFinish , + + +-- ** resolveAsync #method:resolveAsync# + +#if ENABLE_OVERLOADING + RepoFinderResolveAsyncMethodInfo , +#endif + repoFinderResolveAsync , + + +-- ** resolveFinish #method:resolveFinish# + +#if ENABLE_OVERLOADING + RepoFinderResolveFinishMethodInfo , +#endif + repoFinderResolveFinish , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo +import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult + +-- interface RepoFinder +-- | Memory-managed wrapper type. +newtype RepoFinder = RepoFinder (ManagedPtr RepoFinder) +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinder`. +noRepoFinder :: Maybe RepoFinder +noRepoFinder = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFinder = RepoFinderSignalList +type RepoFinderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +foreign import ccall "ostree_repo_finder_get_type" + c_ostree_repo_finder_get_type :: IO GType + +instance GObject RepoFinder where + gobjectType = c_ostree_repo_finder_get_type + + +-- | Type class for types which can be safely cast to `RepoFinder`, for instance with `toRepoFinder`. +class (GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o +instance (GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o + +instance O.HasParentTypes RepoFinder +type instance O.ParentTypes RepoFinder = '[GObject.Object.Object] + +-- | Cast to `RepoFinder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFinder :: (MonadIO m, IsRepoFinder o) => o -> m RepoFinder +toRepoFinder = liftIO . unsafeCastTo RepoFinder + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinder +type instance O.AttributeList RepoFinder = RepoFinderAttributeList +type RepoFinderAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFinderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFinderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFinderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFinderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFinderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFinderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFinderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFinderMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFinderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFinderMethod "resolveAsync" o = RepoFinderResolveAsyncMethodInfo + ResolveRepoFinderMethod "resolveFinish" o = RepoFinderResolveFinishMethodInfo + ResolveRepoFinderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFinderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFinderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFinderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFinderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFinderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFinderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFinderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFinderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFinderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFinderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFinderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderMethod t RepoFinder, O.MethodInfo info RepoFinder p) => OL.IsLabel t (RepoFinder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- method RepoFinder::resolve_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refs", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "non-empty array of collection\8211ref pairs to find remotes for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the local repository which the refs are being resolved for,\n which provides configuration information and GPG keys", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "asynchronous completion callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_resolve_async" ostree_repo_finder_resolve_async :: + Ptr RepoFinder -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinder"}) + Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) + Ptr OSTree.Repo.Repo -> -- parent_repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Find reachable remote URIs which claim to provide any of the given /@refs@/. The +specific method for finding the remotes depends on the 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' +implementation. + +Any remote which is found and which claims to support any of the given /@refs@/ +will be returned in the results. It is possible that a remote claims to +support a given ref, but turns out not to — it is not possible to verify this +until 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' is called. + +The returned results will be sorted with the most useful first — this is +typically the remote which claims to provide the most /@refs@/, at the lowest +latency. + +Each result contains a mapping of /@refs@/ to the checksums of the commits +which the result provides. If the result provides the latest commit for a ref +across all of the results, the checksum will be set. Otherwise, if the +result provides an outdated commit, or doesn’t provide a given ref at all, +the checksum will not be set. Results which provide none of the requested +/@refs@/ may be listed with an empty refs map. + +Pass the results to 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' to pull the given +/@refs@/ from those remotes. + +/Since: 2018.6/ +-} +repoFinderResolveAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFinder a, OSTree.Repo.IsRepo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: an 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' -} + -> [OSTree.CollectionRef.CollectionRef] + {- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for -} + -> b + {- ^ /@parentRepo@/: the local repository which the refs are being resolved for, + which provides configuration information and GPG keys -} + -> Maybe (c) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: asynchronous completion callback -} + -> m () +repoFinderResolveAsync self refs parentRepo cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refs' <- mapM unsafeManagedPtrGetPtr refs + refs'' <- packZeroTerminatedPtrArray refs' + parentRepo' <- unsafeManagedPtrCastPtr parentRepo + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_finder_resolve_async self' refs'' parentRepo' maybeCancellable maybeCallback userData + touchManagedPtr self + mapM_ touchManagedPtr refs + touchManagedPtr parentRepo + whenJust cancellable touchManagedPtr + freeMem refs'' + return () + +#if ENABLE_OVERLOADING +data RepoFinderResolveAsyncMethodInfo +instance (signature ~ ([OSTree.CollectionRef.CollectionRef] -> b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepoFinder a, OSTree.Repo.IsRepo b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoFinderResolveAsyncMethodInfo a signature where + overloadedMethod _ = repoFinderResolveAsync + +#endif + +-- method RepoFinder::resolve_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GAsyncResult from the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TPtrArray (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_finder_resolve_finish" ostree_repo_finder_resolve_finish :: + Ptr RepoFinder -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinder"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (GPtrArray (Ptr OSTree.RepoFinderResult.RepoFinderResult))) + +{- | +Get the results from a 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' operation. + +/Since: 2018.6/ +-} +repoFinderResolveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFinder a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: an 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' -} + -> b + {- ^ /@result@/: 'GI.Gio.Interfaces.AsyncResult.AsyncResult' from the callback -} + -> m [OSTree.RepoFinderResult.RepoFinderResult] + {- ^ __Returns:__ array of zero + or more results /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFinderResolveFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ ostree_repo_finder_resolve_finish self' result_' + checkUnexpectedReturnNULL "repoFinderResolveFinish" result + result' <- unpackGPtrArray result + result'' <- mapM (wrapBoxed OSTree.RepoFinderResult.RepoFinderResult) result' + unrefPtrArray result + touchManagedPtr self + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoFinderResolveFinishMethodInfo +instance (signature ~ (b -> m [OSTree.RepoFinderResult.RepoFinderResult]), MonadIO m, IsRepoFinder a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RepoFinderResolveFinishMethodInfo a signature where + overloadedMethod _ = repoFinderResolveFinish + +#endif + +-- method RepoFinder::resolve_all_async +-- method type : MemberFunction +-- Args : [Arg {argCName = "finders", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "non-empty array of #OstreeRepoFinders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refs", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "non-empty array of collection\8211ref pairs to find remotes for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the local repository which the refs are being resolved for,\n which provides configuration information and GPG keys", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "asynchronous completion callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_resolve_all_async" ostree_repo_finder_resolve_all_async :: + Ptr (Ptr RepoFinder) -> -- finders : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"})) + Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) + Ptr OSTree.Repo.Repo -> -- parent_repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +A version of 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' which queries one or more +/@finders@/ in parallel and combines the results. + +/Since: 2018.6/ +-} +repoFinderResolveAllAsync :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) => + [RepoFinder] + {- ^ /@finders@/: non-empty array of @/OstreeRepoFinders/@ -} + -> [OSTree.CollectionRef.CollectionRef] + {- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for -} + -> a + {- ^ /@parentRepo@/: the local repository which the refs are being resolved for, + which provides configuration information and GPG keys -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: asynchronous completion callback -} + -> m () +repoFinderResolveAllAsync finders refs parentRepo cancellable callback = liftIO $ do + finders' <- mapM unsafeManagedPtrCastPtr finders + finders'' <- packZeroTerminatedPtrArray finders' + refs' <- mapM unsafeManagedPtrGetPtr refs + refs'' <- packZeroTerminatedPtrArray refs' + parentRepo' <- unsafeManagedPtrCastPtr parentRepo + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_finder_resolve_all_async finders'' refs'' parentRepo' maybeCancellable maybeCallback userData + mapM_ touchManagedPtr finders + mapM_ touchManagedPtr refs + touchManagedPtr parentRepo + whenJust cancellable touchManagedPtr + freeMem finders'' + freeMem refs'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method RepoFinder::resolve_all_finish +-- method type : MemberFunction +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GAsyncResult from the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TPtrArray (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_finder_resolve_all_finish" ostree_repo_finder_resolve_all_finish :: + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (GPtrArray (Ptr OSTree.RepoFinderResult.RepoFinderResult))) + +{- | +Get the results from a 'GI.OSTree.Functions.repoFinderResolveAllAsync' operation. + +/Since: 2018.6/ +-} +repoFinderResolveAllFinish :: + (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) => + a + {- ^ /@result@/: 'GI.Gio.Interfaces.AsyncResult.AsyncResult' from the callback -} + -> m [OSTree.RepoFinderResult.RepoFinderResult] + {- ^ __Returns:__ array of zero + or more results /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFinderResolveAllFinish result_ = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ ostree_repo_finder_resolve_all_finish result_' + checkUnexpectedReturnNULL "repoFinderResolveAllFinish" result + result' <- unpackGPtrArray result + result'' <- mapM (wrapBoxed OSTree.RepoFinderResult.RepoFinderResult) result' + unrefPtrArray result + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Interfaces/RepoFinder.hs-boot b/GI/OSTree/Interfaces/RepoFinder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Interfaces/RepoFinder.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Interfaces.RepoFinder 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinder = RepoFinder (ManagedPtr RepoFinder) +instance GObject RepoFinder where +class (GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o +instance (GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o +instance O.HasParentTypes RepoFinder +#if ENABLE_OVERLOADING +data RepoFinderResolveAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFinderResolveFinishMethodInfo +#endif diff --git a/GI/OSTree/Objects.hs b/GI/OSTree/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects.hs @@ -0,0 +1,69 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects + ( module GI.OSTree.Objects.AsyncProgress , + module GI.OSTree.Objects.BootconfigParser, + module GI.OSTree.Objects.ChecksumInputStream, + module GI.OSTree.Objects.Deployment , + module GI.OSTree.Objects.GpgVerifyResult, + module GI.OSTree.Objects.MutableTree , + module GI.OSTree.Objects.Repo , + module GI.OSTree.Objects.RepoFile , + module GI.OSTree.Objects.RepoFinderAvahi, + module GI.OSTree.Objects.RepoFinderConfig, + module GI.OSTree.Objects.RepoFinderMount, + module GI.OSTree.Objects.RepoFinderOverride, + module GI.OSTree.Objects.SePolicy , + module GI.OSTree.Objects.Sysroot , + module GI.OSTree.Objects.SysrootUpgrader, + + + ) where + +import GI.OSTree.Objects.AsyncProgress +import GI.OSTree.Objects.BootconfigParser +import GI.OSTree.Objects.ChecksumInputStream +import GI.OSTree.Objects.Deployment +import GI.OSTree.Objects.GpgVerifyResult +import GI.OSTree.Objects.MutableTree +import GI.OSTree.Objects.Repo +import GI.OSTree.Objects.RepoFile +import GI.OSTree.Objects.RepoFinderAvahi +import GI.OSTree.Objects.RepoFinderConfig +import GI.OSTree.Objects.RepoFinderMount +import GI.OSTree.Objects.RepoFinderOverride +import GI.OSTree.Objects.SePolicy +import GI.OSTree.Objects.Sysroot +import GI.OSTree.Objects.SysrootUpgrader + +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.ManagedPtr as B.ManagedPtr +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.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 + + + diff --git a/GI/OSTree/Objects/AsyncProgress.hs b/GI/OSTree/Objects/AsyncProgress.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/AsyncProgress.hs @@ -0,0 +1,733 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.AsyncProgress + ( + +-- * Exported types + AsyncProgress(..) , + IsAsyncProgress , + toAsyncProgress , + noAsyncProgress , + + + -- * Methods +-- ** finish #method:finish# + +#if ENABLE_OVERLOADING + AsyncProgressFinishMethodInfo , +#endif + asyncProgressFinish , + + +-- ** getStatus #method:getStatus# + +#if ENABLE_OVERLOADING + AsyncProgressGetStatusMethodInfo , +#endif + asyncProgressGetStatus , + + +-- ** getUint #method:getUint# + +#if ENABLE_OVERLOADING + AsyncProgressGetUintMethodInfo , +#endif + asyncProgressGetUint , + + +-- ** getUint64 #method:getUint64# + +#if ENABLE_OVERLOADING + AsyncProgressGetUint64MethodInfo , +#endif + asyncProgressGetUint64 , + + +-- ** getVariant #method:getVariant# + +#if ENABLE_OVERLOADING + AsyncProgressGetVariantMethodInfo , +#endif + asyncProgressGetVariant , + + +-- ** new #method:new# + + asyncProgressNew , + + +-- ** newAndConnect #method:newAndConnect# + + asyncProgressNewAndConnect , + + +-- ** setStatus #method:setStatus# + +#if ENABLE_OVERLOADING + AsyncProgressSetStatusMethodInfo , +#endif + asyncProgressSetStatus , + + +-- ** setUint #method:setUint# + +#if ENABLE_OVERLOADING + AsyncProgressSetUintMethodInfo , +#endif + asyncProgressSetUint , + + +-- ** setUint64 #method:setUint64# + +#if ENABLE_OVERLOADING + AsyncProgressSetUint64MethodInfo , +#endif + asyncProgressSetUint64 , + + +-- ** setVariant #method:setVariant# + +#if ENABLE_OVERLOADING + AsyncProgressSetVariantMethodInfo , +#endif + asyncProgressSetVariant , + + + + + -- * Signals +-- ** changed #signal:changed# + + AsyncProgressChangedCallback , +#if ENABLE_OVERLOADING + AsyncProgressChangedSignalInfo , +#endif + C_AsyncProgressChangedCallback , + afterAsyncProgressChanged , + genClosure_AsyncProgressChanged , + mk_AsyncProgressChangedCallback , + noAsyncProgressChangedCallback , + onAsyncProgressChanged , + wrap_AsyncProgressChangedCallback , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object + +-- | Memory-managed wrapper type. +newtype AsyncProgress = AsyncProgress (ManagedPtr AsyncProgress) +foreign import ccall "ostree_async_progress_get_type" + c_ostree_async_progress_get_type :: IO GType + +instance GObject AsyncProgress where + gobjectType = c_ostree_async_progress_get_type + + +-- | Type class for types which can be safely cast to `AsyncProgress`, for instance with `toAsyncProgress`. +class (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o +instance (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o + +instance O.HasParentTypes AsyncProgress +type instance O.ParentTypes AsyncProgress = '[GObject.Object.Object] + +-- | Cast to `AsyncProgress`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAsyncProgress :: (MonadIO m, IsAsyncProgress o) => o -> m AsyncProgress +toAsyncProgress = liftIO . unsafeCastTo AsyncProgress + +-- | A convenience alias for `Nothing` :: `Maybe` `AsyncProgress`. +noAsyncProgress :: Maybe AsyncProgress +noAsyncProgress = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAsyncProgressMethod (t :: Symbol) (o :: *) :: * where + ResolveAsyncProgressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAsyncProgressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAsyncProgressMethod "finish" o = AsyncProgressFinishMethodInfo + ResolveAsyncProgressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAsyncProgressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAsyncProgressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAsyncProgressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAsyncProgressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAsyncProgressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAsyncProgressMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAsyncProgressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAsyncProgressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAsyncProgressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAsyncProgressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAsyncProgressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAsyncProgressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAsyncProgressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAsyncProgressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAsyncProgressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAsyncProgressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAsyncProgressMethod "getStatus" o = AsyncProgressGetStatusMethodInfo + ResolveAsyncProgressMethod "getUint" o = AsyncProgressGetUintMethodInfo + ResolveAsyncProgressMethod "getUint64" o = AsyncProgressGetUint64MethodInfo + ResolveAsyncProgressMethod "getVariant" o = AsyncProgressGetVariantMethodInfo + ResolveAsyncProgressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAsyncProgressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAsyncProgressMethod "setStatus" o = AsyncProgressSetStatusMethodInfo + ResolveAsyncProgressMethod "setUint" o = AsyncProgressSetUintMethodInfo + ResolveAsyncProgressMethod "setUint64" o = AsyncProgressSetUint64MethodInfo + ResolveAsyncProgressMethod "setVariant" o = AsyncProgressSetVariantMethodInfo + ResolveAsyncProgressMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAsyncProgressMethod t AsyncProgress, O.MethodInfo info AsyncProgress p) => OL.IsLabel t (AsyncProgress -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- signal AsyncProgress::changed +{- | +Emitted when /@self@/ has been changed. +-} +type AsyncProgressChangedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `AsyncProgressChangedCallback`@. +noAsyncProgressChangedCallback :: Maybe AsyncProgressChangedCallback +noAsyncProgressChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_AsyncProgressChangedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_AsyncProgressChangedCallback`. +foreign import ccall "wrapper" + mk_AsyncProgressChangedCallback :: C_AsyncProgressChangedCallback -> IO (FunPtr C_AsyncProgressChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_AsyncProgressChanged :: MonadIO m => AsyncProgressChangedCallback -> m (GClosure C_AsyncProgressChangedCallback) +genClosure_AsyncProgressChanged cb = liftIO $ do + let cb' = wrap_AsyncProgressChangedCallback cb + mk_AsyncProgressChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `AsyncProgressChangedCallback` into a `C_AsyncProgressChangedCallback`. +wrap_AsyncProgressChangedCallback :: + AsyncProgressChangedCallback -> + C_AsyncProgressChangedCallback +wrap_AsyncProgressChangedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' asyncProgress #changed callback +@ +-} +onAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId +onAsyncProgressChanged obj cb = liftIO $ do + let cb' = wrap_AsyncProgressChangedCallback cb + cb'' <- mk_AsyncProgressChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' asyncProgress #changed callback +@ +-} +afterAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId +afterAsyncProgressChanged obj cb = liftIO $ do + let cb' = wrap_AsyncProgressChangedCallback cb + cb'' <- mk_AsyncProgressChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AsyncProgress +type instance O.AttributeList AsyncProgress = AsyncProgressAttributeList +type AsyncProgressAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data AsyncProgressChangedSignalInfo +instance SignalInfo AsyncProgressChangedSignalInfo where + type HaskellCallbackType AsyncProgressChangedSignalInfo = AsyncProgressChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_AsyncProgressChangedCallback cb + cb'' <- mk_AsyncProgressChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' connectMode + +type instance O.SignalList AsyncProgress = AsyncProgressSignalList +type AsyncProgressSignalList = ('[ '("changed", AsyncProgressChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AsyncProgress::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_new" ostree_async_progress_new :: + IO (Ptr AsyncProgress) + +{- | +/No description available in the introspection data./ +-} +asyncProgressNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m AsyncProgress + {- ^ __Returns:__ A new progress object -} +asyncProgressNew = liftIO $ do + result <- ostree_async_progress_new + checkUnexpectedReturnNULL "asyncProgressNew" result + result' <- (wrapObject AsyncProgress) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AsyncProgress::new_and_connect +-- method type : Constructor +-- Args : [Arg {argCName = "changed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_new_and_connect" ostree_async_progress_new_and_connect :: + Ptr () -> -- changed : TBasicType TPtr + Ptr () -> -- user_data : TBasicType TPtr + IO (Ptr AsyncProgress) + +{- | +/No description available in the introspection data./ +-} +asyncProgressNewAndConnect :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -> Ptr () + -> m AsyncProgress +asyncProgressNewAndConnect changed userData = liftIO $ do + result <- ostree_async_progress_new_and_connect changed userData + checkUnexpectedReturnNULL "asyncProgressNewAndConnect" result + result' <- (wrapObject AsyncProgress) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AsyncProgress::finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_finish" ostree_async_progress_finish :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + IO () + +{- | +Process any pending signals, ensuring the main context is cleared +of sources used by this object. Also ensures that no further +events will be queued. +-} +asyncProgressFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + {- ^ /@self@/: Self -} + -> m () +asyncProgressFinish self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_async_progress_finish self' + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data AsyncProgressFinishMethodInfo +instance (signature ~ (m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressFinishMethodInfo a signature where + overloadedMethod _ = asyncProgressFinish + +#endif + +-- method AsyncProgress::get_status +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_get_status" ostree_async_progress_get_status :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + IO CString + +{- | +Get the human-readable status string from the 'GI.OSTree.Objects.AsyncProgress.AsyncProgress'. This +operation is thread-safe. The retuned value may be 'Nothing' if no status is +set. + +This is a convenience function to get the well-known @status@ key. + +/Since: 2017.6/ +-} +asyncProgressGetStatus :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the current status, or 'Nothing' if none is set -} +asyncProgressGetStatus self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_async_progress_get_status self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr self + return maybeResult + +#if ENABLE_OVERLOADING +data AsyncProgressGetStatusMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetStatusMethodInfo a signature where + overloadedMethod _ = asyncProgressGetStatus + +#endif + +-- method AsyncProgress::get_uint +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_get_uint" ostree_async_progress_get_uint :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + IO Word32 + +{- | +/No description available in the introspection data./ +-} +asyncProgressGetUint :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + -> T.Text + -> m Word32 +asyncProgressGetUint self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- ostree_async_progress_get_uint self' key' + touchManagedPtr self + freeMem key' + return result + +#if ENABLE_OVERLOADING +data AsyncProgressGetUintMethodInfo +instance (signature ~ (T.Text -> m Word32), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUintMethodInfo a signature where + overloadedMethod _ = asyncProgressGetUint + +#endif + +-- method AsyncProgress::get_uint64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_get_uint64" ostree_async_progress_get_uint64 :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + IO Word64 + +{- | +/No description available in the introspection data./ +-} +asyncProgressGetUint64 :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + -> T.Text + -> m Word64 +asyncProgressGetUint64 self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- ostree_async_progress_get_uint64 self' key' + touchManagedPtr self + freeMem key' + return result + +#if ENABLE_OVERLOADING +data AsyncProgressGetUint64MethodInfo +instance (signature ~ (T.Text -> m Word64), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUint64MethodInfo a signature where + overloadedMethod _ = asyncProgressGetUint64 + +#endif + +-- method AsyncProgress::get_variant +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a key to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_get_variant" ostree_async_progress_get_variant :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + IO (Ptr GVariant) + +{- | +Look up a key in the 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' and return the 'GVariant' associated +with it. The lookup is thread-safe. + +/Since: 2017.6/ +-} +asyncProgressGetVariant :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' -} + -> T.Text + {- ^ /@key@/: a key to look up -} + -> m (Maybe GVariant) + {- ^ __Returns:__ value for the given /@key@/, or 'Nothing' if + it was not set -} +asyncProgressGetVariant self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- ostree_async_progress_get_variant self' key' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- B.GVariant.wrapGVariantPtr result' + return result'' + touchManagedPtr self + freeMem key' + return maybeResult + +#if ENABLE_OVERLOADING +data AsyncProgressGetVariantMethodInfo +instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetVariantMethodInfo a signature where + overloadedMethod _ = asyncProgressGetVariant + +#endif + +-- method AsyncProgress::set_status +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new status string, or %NULL to clear the status", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_set_status" ostree_async_progress_set_status :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- status : TBasicType TUTF8 + IO () + +{- | +Set the human-readable status string for the 'GI.OSTree.Objects.AsyncProgress.AsyncProgress'. This +operation is thread-safe. 'Nothing' may be passed to clear the status. + +This is a convenience function to set the well-known @status@ key. + +/Since: 2017.6/ +-} +asyncProgressSetStatus :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' -} + -> Maybe (T.Text) + {- ^ /@status@/: new status string, or 'Nothing' to clear the status -} + -> m () +asyncProgressSetStatus self status = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeStatus <- case status of + Nothing -> return nullPtr + Just jStatus -> do + jStatus' <- textToCString jStatus + return jStatus' + ostree_async_progress_set_status self' maybeStatus + touchManagedPtr self + freeMem maybeStatus + return () + +#if ENABLE_OVERLOADING +data AsyncProgressSetStatusMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetStatusMethodInfo a signature where + overloadedMethod _ = asyncProgressSetStatus + +#endif + +-- method AsyncProgress::set_uint +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_set_uint" ostree_async_progress_set_uint :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + Word32 -> -- value : TBasicType TUInt + IO () + +{- | +/No description available in the introspection data./ +-} +asyncProgressSetUint :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + -> T.Text + -> Word32 + -> m () +asyncProgressSetUint self key value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + ostree_async_progress_set_uint self' key' value + touchManagedPtr self + freeMem key' + return () + +#if ENABLE_OVERLOADING +data AsyncProgressSetUintMethodInfo +instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUintMethodInfo a signature where + overloadedMethod _ = asyncProgressSetUint + +#endif + +-- method AsyncProgress::set_uint64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_set_uint64" ostree_async_progress_set_uint64 :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + Word64 -> -- value : TBasicType TUInt64 + IO () + +{- | +/No description available in the introspection data./ +-} +asyncProgressSetUint64 :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + -> T.Text + -> Word64 + -> m () +asyncProgressSetUint64 self key value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + ostree_async_progress_set_uint64 self' key' value + touchManagedPtr self + freeMem key' + return () + +#if ENABLE_OVERLOADING +data AsyncProgressSetUint64MethodInfo +instance (signature ~ (T.Text -> Word64 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUint64MethodInfo a signature where + overloadedMethod _ = asyncProgressSetUint64 + +#endif + +-- method AsyncProgress::set_variant +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a key to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to assign to @key", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_async_progress_set_variant" ostree_async_progress_set_variant :: + Ptr AsyncProgress -> -- self : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + CString -> -- key : TBasicType TUTF8 + Ptr GVariant -> -- value : TVariant + IO () + +{- | +Assign a new /@value@/ to the given /@key@/, replacing any existing value. The +operation is thread-safe. /@value@/ may be a floating reference; +'GI.GLib.Structs.Variant.variantRefSink' will be called on it. + +Any watchers of the 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' will be notified of the change if +/@value@/ differs from the existing value for /@key@/. + +/Since: 2017.6/ +-} +asyncProgressSetVariant :: + (B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' -} + -> T.Text + {- ^ /@key@/: a key to set -} + -> GVariant + {- ^ /@value@/: the value to assign to /@key@/ -} + -> m () +asyncProgressSetVariant self key value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + value' <- unsafeManagedPtrGetPtr value + ostree_async_progress_set_variant self' key' value' + touchManagedPtr self + touchManagedPtr value + freeMem key' + return () + +#if ENABLE_OVERLOADING +data AsyncProgressSetVariantMethodInfo +instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetVariantMethodInfo a signature where + overloadedMethod _ = asyncProgressSetVariant + +#endif + + diff --git a/GI/OSTree/Objects/AsyncProgress.hs-boot b/GI/OSTree/Objects/AsyncProgress.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/AsyncProgress.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.AsyncProgress 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype AsyncProgress = AsyncProgress (ManagedPtr AsyncProgress) +instance GObject AsyncProgress where +class (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o +instance (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o +instance O.HasParentTypes AsyncProgress +#if ENABLE_OVERLOADING +data AsyncProgressChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressGetStatusMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressGetUintMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressGetUint64MethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressGetVariantMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressSetStatusMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressSetUintMethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressSetUint64MethodInfo +#endif +#if ENABLE_OVERLOADING +data AsyncProgressSetVariantMethodInfo +#endif diff --git a/GI/OSTree/Objects/BootconfigParser.hs b/GI/OSTree/Objects/BootconfigParser.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/BootconfigParser.hs @@ -0,0 +1,542 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.BootconfigParser + ( + +-- * Exported types + BootconfigParser(..) , + IsBootconfigParser , + toBootconfigParser , + noBootconfigParser , + + + -- * Methods +-- ** clone #method:clone# + +#if ENABLE_OVERLOADING + BootconfigParserCloneMethodInfo , +#endif + bootconfigParserClone , + + +-- ** get #method:get# + +#if ENABLE_OVERLOADING + BootconfigParserGetMethodInfo , +#endif + bootconfigParserGet , + + +-- ** new #method:new# + + bootconfigParserNew , + + +-- ** parse #method:parse# + +#if ENABLE_OVERLOADING + BootconfigParserParseMethodInfo , +#endif + bootconfigParserParse , + + +-- ** parseAt #method:parseAt# + +#if ENABLE_OVERLOADING + BootconfigParserParseAtMethodInfo , +#endif + bootconfigParserParseAt , + + +-- ** set #method:set# + +#if ENABLE_OVERLOADING + BootconfigParserSetMethodInfo , +#endif + bootconfigParserSet , + + +-- ** write #method:write# + +#if ENABLE_OVERLOADING + BootconfigParserWriteMethodInfo , +#endif + bootconfigParserWrite , + + +-- ** writeAt #method:writeAt# + +#if ENABLE_OVERLOADING + BootconfigParserWriteAtMethodInfo , +#endif + bootconfigParserWriteAt , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable + +-- | Memory-managed wrapper type. +newtype BootconfigParser = BootconfigParser (ManagedPtr BootconfigParser) +foreign import ccall "ostree_bootconfig_parser_get_type" + c_ostree_bootconfig_parser_get_type :: IO GType + +instance GObject BootconfigParser where + gobjectType = c_ostree_bootconfig_parser_get_type + + +-- | Type class for types which can be safely cast to `BootconfigParser`, for instance with `toBootconfigParser`. +class (GObject o, O.IsDescendantOf BootconfigParser o) => IsBootconfigParser o +instance (GObject o, O.IsDescendantOf BootconfigParser o) => IsBootconfigParser o + +instance O.HasParentTypes BootconfigParser +type instance O.ParentTypes BootconfigParser = '[GObject.Object.Object] + +-- | Cast to `BootconfigParser`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBootconfigParser :: (MonadIO m, IsBootconfigParser o) => o -> m BootconfigParser +toBootconfigParser = liftIO . unsafeCastTo BootconfigParser + +-- | A convenience alias for `Nothing` :: `Maybe` `BootconfigParser`. +noBootconfigParser :: Maybe BootconfigParser +noBootconfigParser = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBootconfigParserMethod (t :: Symbol) (o :: *) :: * where + ResolveBootconfigParserMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBootconfigParserMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBootconfigParserMethod "clone" o = BootconfigParserCloneMethodInfo + ResolveBootconfigParserMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBootconfigParserMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBootconfigParserMethod "get" o = BootconfigParserGetMethodInfo + ResolveBootconfigParserMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBootconfigParserMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBootconfigParserMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBootconfigParserMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBootconfigParserMethod "parse" o = BootconfigParserParseMethodInfo + ResolveBootconfigParserMethod "parseAt" o = BootconfigParserParseAtMethodInfo + ResolveBootconfigParserMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBootconfigParserMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBootconfigParserMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBootconfigParserMethod "set" o = BootconfigParserSetMethodInfo + ResolveBootconfigParserMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBootconfigParserMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBootconfigParserMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBootconfigParserMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBootconfigParserMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBootconfigParserMethod "write" o = BootconfigParserWriteMethodInfo + ResolveBootconfigParserMethod "writeAt" o = BootconfigParserWriteAtMethodInfo + ResolveBootconfigParserMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBootconfigParserMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBootconfigParserMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBootconfigParserMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBootconfigParserMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBootconfigParserMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootconfigParserMethod t BootconfigParser, O.MethodInfo info BootconfigParser p) => OL.IsLabel t (BootconfigParser -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BootconfigParser +type instance O.AttributeList BootconfigParser = BootconfigParserAttributeList +type BootconfigParserAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList BootconfigParser = BootconfigParserSignalList +type BootconfigParserSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method BootconfigParser::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "BootconfigParser"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_new" ostree_bootconfig_parser_new :: + IO (Ptr BootconfigParser) + +{- | +/No description available in the introspection data./ +-} +bootconfigParserNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m BootconfigParser +bootconfigParserNew = liftIO $ do + result <- ostree_bootconfig_parser_new + checkUnexpectedReturnNULL "bootconfigParserNew" result + result' <- (wrapObject BootconfigParser) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method BootconfigParser::clone +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Bootconfig to clone", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "BootconfigParser"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_clone" ostree_bootconfig_parser_clone :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + IO (Ptr BootconfigParser) + +{- | +/No description available in the introspection data./ +-} +bootconfigParserClone :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a) => + a + {- ^ /@self@/: Bootconfig to clone -} + -> m BootconfigParser + {- ^ __Returns:__ Copy of /@self@/ -} +bootconfigParserClone self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_bootconfig_parser_clone self' + checkUnexpectedReturnNULL "bootconfigParserClone" result + result' <- (wrapObject BootconfigParser) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data BootconfigParserCloneMethodInfo +instance (signature ~ (m BootconfigParser), MonadIO m, IsBootconfigParser a) => O.MethodInfo BootconfigParserCloneMethodInfo a signature where + overloadedMethod _ = bootconfigParserClone + +#endif + +-- method BootconfigParser::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_get" ostree_bootconfig_parser_get :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + CString -> -- key : TBasicType TUTF8 + IO CString + +{- | +/No description available in the introspection data./ +-} +bootconfigParserGet :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a) => + a + -> T.Text + -> m T.Text +bootconfigParserGet self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- ostree_bootconfig_parser_get self' key' + checkUnexpectedReturnNULL "bootconfigParserGet" result + result' <- cstringToText result + touchManagedPtr self + freeMem key' + return result' + +#if ENABLE_OVERLOADING +data BootconfigParserGetMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsBootconfigParser a) => O.MethodInfo BootconfigParserGetMethodInfo a signature where + overloadedMethod _ = bootconfigParserGet + +#endif + +-- method BootconfigParser::parse +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_parse" ostree_bootconfig_parser_parse :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + Ptr Gio.File.File -> -- path : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +bootconfigParserParse :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + -> b + -> Maybe (c) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +bootconfigParserParse self path cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- unsafeManagedPtrCastPtr path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_bootconfig_parser_parse self' path' maybeCancellable + touchManagedPtr self + touchManagedPtr path + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BootconfigParserParseMethodInfo +instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsBootconfigParser a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo BootconfigParserParseMethodInfo a signature where + overloadedMethod _ = bootconfigParserParse + +#endif + +-- method BootconfigParser::parse_at +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Parser", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory fd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_parse_at" ostree_bootconfig_parser_parse_at :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Initialize a bootconfig from the given file. +-} +bootconfigParserParseAt :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Parser -} + -> Int32 + {- ^ /@dfd@/: Directory fd -} + -> T.Text + {- ^ /@path@/: File path -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +bootconfigParserParseAt self dfd path cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_bootconfig_parser_parse_at self' dfd path' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data BootconfigParserParseAtMethodInfo +instance (signature ~ (Int32 -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsBootconfigParser a, Gio.Cancellable.IsCancellable b) => O.MethodInfo BootconfigParserParseAtMethodInfo a signature where + overloadedMethod _ = bootconfigParserParseAt + +#endif + +-- method BootconfigParser::set +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_set" ostree_bootconfig_parser_set :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + CString -> -- key : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +bootconfigParserSet :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a) => + a + -> T.Text + -> T.Text + -> m () +bootconfigParserSet self key value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + value' <- textToCString value + ostree_bootconfig_parser_set self' key' value' + touchManagedPtr self + freeMem key' + freeMem value' + return () + +#if ENABLE_OVERLOADING +data BootconfigParserSetMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsBootconfigParser a) => O.MethodInfo BootconfigParserSetMethodInfo a signature where + overloadedMethod _ = bootconfigParserSet + +#endif + +-- method BootconfigParser::write +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "output", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_write" ostree_bootconfig_parser_write :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + Ptr Gio.File.File -> -- output : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +bootconfigParserWrite :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + -> b + -> Maybe (c) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +bootconfigParserWrite self output cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + output' <- unsafeManagedPtrCastPtr output + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_bootconfig_parser_write self' output' maybeCancellable + touchManagedPtr self + touchManagedPtr output + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BootconfigParserWriteMethodInfo +instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsBootconfigParser a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo BootconfigParserWriteMethodInfo a signature where + overloadedMethod _ = bootconfigParserWrite + +#endif + +-- method BootconfigParser::write_at +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_bootconfig_parser_write_at" ostree_bootconfig_parser_write_at :: + Ptr BootconfigParser -> -- self : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +bootconfigParserWriteAt :: + (B.CallStack.HasCallStack, MonadIO m, IsBootconfigParser a, Gio.Cancellable.IsCancellable b) => + a + -> Int32 + -> T.Text + -> Maybe (b) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +bootconfigParserWriteAt self dfd path cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_bootconfig_parser_write_at self' dfd path' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data BootconfigParserWriteAtMethodInfo +instance (signature ~ (Int32 -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsBootconfigParser a, Gio.Cancellable.IsCancellable b) => O.MethodInfo BootconfigParserWriteAtMethodInfo a signature where + overloadedMethod _ = bootconfigParserWriteAt + +#endif + + diff --git a/GI/OSTree/Objects/BootconfigParser.hs-boot b/GI/OSTree/Objects/BootconfigParser.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/BootconfigParser.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.BootconfigParser 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype BootconfigParser = BootconfigParser (ManagedPtr BootconfigParser) +instance GObject BootconfigParser where +class (GObject o, O.IsDescendantOf BootconfigParser o) => IsBootconfigParser o +instance (GObject o, O.IsDescendantOf BootconfigParser o) => IsBootconfigParser o +instance O.HasParentTypes BootconfigParser +#if ENABLE_OVERLOADING +data BootconfigParserCloneMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserParseMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserParseAtMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserSetMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserWriteMethodInfo +#endif +#if ENABLE_OVERLOADING +data BootconfigParserWriteAtMethodInfo +#endif diff --git a/GI/OSTree/Objects/ChecksumInputStream.hs b/GI/OSTree/Objects/ChecksumInputStream.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/ChecksumInputStream.hs @@ -0,0 +1,244 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.ChecksumInputStream + ( + +-- * Exported types + ChecksumInputStream(..) , + IsChecksumInputStream , + toChecksumInputStream , + noChecksumInputStream , + + + -- * Methods +-- ** new #method:new# + + checksumInputStreamNew , + + + + + -- * Properties +-- ** checksum #attr:checksum# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ChecksumInputStreamChecksumPropertyInfo , +#endif +#if ENABLE_OVERLOADING + checksumInputStreamChecksum , +#endif + constructChecksumInputStreamChecksum , + getChecksumInputStreamChecksum , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.Checksum as GLib.Checksum +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream +import qualified GI.Gio.Objects.InputStream as Gio.InputStream + +-- | Memory-managed wrapper type. +newtype ChecksumInputStream = ChecksumInputStream (ManagedPtr ChecksumInputStream) +foreign import ccall "ostree_checksum_input_stream_get_type" + c_ostree_checksum_input_stream_get_type :: IO GType + +instance GObject ChecksumInputStream where + gobjectType = c_ostree_checksum_input_stream_get_type + + +-- | Type class for types which can be safely cast to `ChecksumInputStream`, for instance with `toChecksumInputStream`. +class (GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o +instance (GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o + +instance O.HasParentTypes ChecksumInputStream +type instance O.ParentTypes ChecksumInputStream = '[Gio.FilterInputStream.FilterInputStream, Gio.InputStream.InputStream, GObject.Object.Object] + +-- | Cast to `ChecksumInputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toChecksumInputStream :: (MonadIO m, IsChecksumInputStream o) => o -> m ChecksumInputStream +toChecksumInputStream = liftIO . unsafeCastTo ChecksumInputStream + +-- | A convenience alias for `Nothing` :: `Maybe` `ChecksumInputStream`. +noChecksumInputStream :: Maybe ChecksumInputStream +noChecksumInputStream = Nothing + +#if ENABLE_OVERLOADING +type family ResolveChecksumInputStreamMethod (t :: Symbol) (o :: *) :: * where + ResolveChecksumInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveChecksumInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveChecksumInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo + ResolveChecksumInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo + ResolveChecksumInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo + ResolveChecksumInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo + ResolveChecksumInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveChecksumInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveChecksumInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveChecksumInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo + ResolveChecksumInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo + ResolveChecksumInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveChecksumInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveChecksumInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveChecksumInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo + ResolveChecksumInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo + ResolveChecksumInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo + ResolveChecksumInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo + ResolveChecksumInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo + ResolveChecksumInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo + ResolveChecksumInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo + ResolveChecksumInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo + ResolveChecksumInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo + ResolveChecksumInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveChecksumInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveChecksumInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveChecksumInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo + ResolveChecksumInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo + ResolveChecksumInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo + ResolveChecksumInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveChecksumInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveChecksumInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveChecksumInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveChecksumInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveChecksumInputStreamMethod "getBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetBaseStreamMethodInfo + ResolveChecksumInputStreamMethod "getCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetCloseBaseStreamMethodInfo + ResolveChecksumInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveChecksumInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveChecksumInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveChecksumInputStreamMethod "setCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamSetCloseBaseStreamMethodInfo + ResolveChecksumInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveChecksumInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo + ResolveChecksumInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveChecksumInputStreamMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveChecksumInputStreamMethod t ChecksumInputStream, O.MethodInfo info ChecksumInputStream p) => OL.IsLabel t (ChecksumInputStream -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "checksum" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@checksum@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checksumInputStream #checksum +@ +-} +getChecksumInputStreamChecksum :: (MonadIO m, IsChecksumInputStream o) => o -> m (Ptr ()) +getChecksumInputStreamChecksum obj = liftIO $ B.Properties.getObjectPropertyPtr obj "checksum" + +{- | +Construct a `GValueConstruct` with valid value for the “@checksum@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructChecksumInputStreamChecksum :: (IsChecksumInputStream o) => Ptr () -> IO (GValueConstruct o) +constructChecksumInputStreamChecksum val = B.Properties.constructObjectPropertyPtr "checksum" val + +#if ENABLE_OVERLOADING +data ChecksumInputStreamChecksumPropertyInfo +instance AttrInfo ChecksumInputStreamChecksumPropertyInfo where + type AttrAllowedOps ChecksumInputStreamChecksumPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ChecksumInputStreamChecksumPropertyInfo = (~) (Ptr ()) + type AttrBaseTypeConstraint ChecksumInputStreamChecksumPropertyInfo = IsChecksumInputStream + type AttrGetType ChecksumInputStreamChecksumPropertyInfo = (Ptr ()) + type AttrLabel ChecksumInputStreamChecksumPropertyInfo = "checksum" + type AttrOrigin ChecksumInputStreamChecksumPropertyInfo = ChecksumInputStream + attrGet _ = getChecksumInputStreamChecksum + attrSet _ = undefined + attrConstruct _ = constructChecksumInputStreamChecksum + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ChecksumInputStream +type instance O.AttributeList ChecksumInputStream = ChecksumInputStreamAttributeList +type ChecksumInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("checksum", ChecksumInputStreamChecksumPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +checksumInputStreamChecksum :: AttrLabelProxy "checksum" +checksumInputStreamChecksum = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ChecksumInputStream = ChecksumInputStreamSignalList +type ChecksumInputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ChecksumInputStream::new +-- method type : Constructor +-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TInterface (Name {namespace = "GLib", name = "Checksum"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "ChecksumInputStream"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_checksum_input_stream_new" ostree_checksum_input_stream_new :: + Ptr Gio.InputStream.InputStream -> -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr GLib.Checksum.Checksum -> -- checksum : TInterface (Name {namespace = "GLib", name = "Checksum"}) + IO (Ptr ChecksumInputStream) + +{- | +/No description available in the introspection data./ +-} +checksumInputStreamNew :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) => + a + -> GLib.Checksum.Checksum + -> m ChecksumInputStream +checksumInputStreamNew stream checksum = liftIO $ do + stream' <- unsafeManagedPtrCastPtr stream + checksum' <- unsafeManagedPtrGetPtr checksum + result <- ostree_checksum_input_stream_new stream' checksum' + checkUnexpectedReturnNULL "checksumInputStreamNew" result + result' <- (wrapObject ChecksumInputStream) result + touchManagedPtr stream + touchManagedPtr checksum + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/ChecksumInputStream.hs-boot b/GI/OSTree/Objects/ChecksumInputStream.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/ChecksumInputStream.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.ChecksumInputStream 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype ChecksumInputStream = ChecksumInputStream (ManagedPtr ChecksumInputStream) +instance GObject ChecksumInputStream where +class (GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o +instance (GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o +instance O.HasParentTypes ChecksumInputStream +#if ENABLE_OVERLOADING +data ChecksumInputStreamChecksumPropertyInfo +#endif diff --git a/GI/OSTree/Objects/Deployment.hs b/GI/OSTree/Objects/Deployment.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Deployment.hs @@ -0,0 +1,1084 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.Deployment + ( + +-- * Exported types + Deployment(..) , + IsDeployment , + toDeployment , + noDeployment , + + + -- * Methods +-- ** clone #method:clone# + +#if ENABLE_OVERLOADING + DeploymentCloneMethodInfo , +#endif + deploymentClone , + + +-- ** equal #method:equal# + +#if ENABLE_OVERLOADING + DeploymentEqualMethodInfo , +#endif + deploymentEqual , + + +-- ** getBootconfig #method:getBootconfig# + +#if ENABLE_OVERLOADING + DeploymentGetBootconfigMethodInfo , +#endif + deploymentGetBootconfig , + + +-- ** getBootcsum #method:getBootcsum# + +#if ENABLE_OVERLOADING + DeploymentGetBootcsumMethodInfo , +#endif + deploymentGetBootcsum , + + +-- ** getBootserial #method:getBootserial# + +#if ENABLE_OVERLOADING + DeploymentGetBootserialMethodInfo , +#endif + deploymentGetBootserial , + + +-- ** getCsum #method:getCsum# + +#if ENABLE_OVERLOADING + DeploymentGetCsumMethodInfo , +#endif + deploymentGetCsum , + + +-- ** getDeployserial #method:getDeployserial# + +#if ENABLE_OVERLOADING + DeploymentGetDeployserialMethodInfo , +#endif + deploymentGetDeployserial , + + +-- ** getIndex #method:getIndex# + +#if ENABLE_OVERLOADING + DeploymentGetIndexMethodInfo , +#endif + deploymentGetIndex , + + +-- ** getOrigin #method:getOrigin# + +#if ENABLE_OVERLOADING + DeploymentGetOriginMethodInfo , +#endif + deploymentGetOrigin , + + +-- ** getOriginRelpath #method:getOriginRelpath# + +#if ENABLE_OVERLOADING + DeploymentGetOriginRelpathMethodInfo , +#endif + deploymentGetOriginRelpath , + + +-- ** getOsname #method:getOsname# + +#if ENABLE_OVERLOADING + DeploymentGetOsnameMethodInfo , +#endif + deploymentGetOsname , + + +-- ** getUnlocked #method:getUnlocked# + +#if ENABLE_OVERLOADING + DeploymentGetUnlockedMethodInfo , +#endif + deploymentGetUnlocked , + + +-- ** hash #method:hash# + + deploymentHash , + + +-- ** isPinned #method:isPinned# + +#if ENABLE_OVERLOADING + DeploymentIsPinnedMethodInfo , +#endif + deploymentIsPinned , + + +-- ** isStaged #method:isStaged# + +#if ENABLE_OVERLOADING + DeploymentIsStagedMethodInfo , +#endif + deploymentIsStaged , + + +-- ** new #method:new# + + deploymentNew , + + +-- ** originRemoveTransientState #method:originRemoveTransientState# + + deploymentOriginRemoveTransientState , + + +-- ** setBootconfig #method:setBootconfig# + +#if ENABLE_OVERLOADING + DeploymentSetBootconfigMethodInfo , +#endif + deploymentSetBootconfig , + + +-- ** setBootserial #method:setBootserial# + +#if ENABLE_OVERLOADING + DeploymentSetBootserialMethodInfo , +#endif + deploymentSetBootserial , + + +-- ** setIndex #method:setIndex# + +#if ENABLE_OVERLOADING + DeploymentSetIndexMethodInfo , +#endif + deploymentSetIndex , + + +-- ** setOrigin #method:setOrigin# + +#if ENABLE_OVERLOADING + DeploymentSetOriginMethodInfo , +#endif + deploymentSetOrigin , + + +-- ** unlockedStateToString #method:unlockedStateToString# + + deploymentUnlockedStateToString , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.KeyFile as GLib.KeyFile +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Objects.BootconfigParser as OSTree.BootconfigParser + +-- | Memory-managed wrapper type. +newtype Deployment = Deployment (ManagedPtr Deployment) +foreign import ccall "ostree_deployment_get_type" + c_ostree_deployment_get_type :: IO GType + +instance GObject Deployment where + gobjectType = c_ostree_deployment_get_type + + +-- | Type class for types which can be safely cast to `Deployment`, for instance with `toDeployment`. +class (GObject o, O.IsDescendantOf Deployment o) => IsDeployment o +instance (GObject o, O.IsDescendantOf Deployment o) => IsDeployment o + +instance O.HasParentTypes Deployment +type instance O.ParentTypes Deployment = '[GObject.Object.Object] + +-- | Cast to `Deployment`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDeployment :: (MonadIO m, IsDeployment o) => o -> m Deployment +toDeployment = liftIO . unsafeCastTo Deployment + +-- | A convenience alias for `Nothing` :: `Maybe` `Deployment`. +noDeployment :: Maybe Deployment +noDeployment = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDeploymentMethod (t :: Symbol) (o :: *) :: * where + ResolveDeploymentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDeploymentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDeploymentMethod "clone" o = DeploymentCloneMethodInfo + ResolveDeploymentMethod "equal" o = DeploymentEqualMethodInfo + ResolveDeploymentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDeploymentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDeploymentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDeploymentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDeploymentMethod "isPinned" o = DeploymentIsPinnedMethodInfo + ResolveDeploymentMethod "isStaged" o = DeploymentIsStagedMethodInfo + ResolveDeploymentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDeploymentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDeploymentMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDeploymentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDeploymentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDeploymentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDeploymentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDeploymentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDeploymentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDeploymentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDeploymentMethod "getBootconfig" o = DeploymentGetBootconfigMethodInfo + ResolveDeploymentMethod "getBootcsum" o = DeploymentGetBootcsumMethodInfo + ResolveDeploymentMethod "getBootserial" o = DeploymentGetBootserialMethodInfo + ResolveDeploymentMethod "getCsum" o = DeploymentGetCsumMethodInfo + ResolveDeploymentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDeploymentMethod "getDeployserial" o = DeploymentGetDeployserialMethodInfo + ResolveDeploymentMethod "getIndex" o = DeploymentGetIndexMethodInfo + ResolveDeploymentMethod "getOrigin" o = DeploymentGetOriginMethodInfo + ResolveDeploymentMethod "getOriginRelpath" o = DeploymentGetOriginRelpathMethodInfo + ResolveDeploymentMethod "getOsname" o = DeploymentGetOsnameMethodInfo + ResolveDeploymentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDeploymentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDeploymentMethod "getUnlocked" o = DeploymentGetUnlockedMethodInfo + ResolveDeploymentMethod "setBootconfig" o = DeploymentSetBootconfigMethodInfo + ResolveDeploymentMethod "setBootserial" o = DeploymentSetBootserialMethodInfo + ResolveDeploymentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDeploymentMethod "setIndex" o = DeploymentSetIndexMethodInfo + ResolveDeploymentMethod "setOrigin" o = DeploymentSetOriginMethodInfo + ResolveDeploymentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDeploymentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDeploymentMethod t Deployment, O.MethodInfo info Deployment p) => OL.IsLabel t (Deployment -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Deployment +type instance O.AttributeList Deployment = DeploymentAttributeList +type DeploymentAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Deployment = DeploymentSignalList +type DeploymentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Deployment::new +-- method type : Constructor +-- Args : [Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "csum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployserial", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bootcsum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bootserial", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_new" ostree_deployment_new :: + Int32 -> -- index : TBasicType TInt + CString -> -- osname : TBasicType TUTF8 + CString -> -- csum : TBasicType TUTF8 + Int32 -> -- deployserial : TBasicType TInt + CString -> -- bootcsum : TBasicType TUTF8 + Int32 -> -- bootserial : TBasicType TInt + IO (Ptr Deployment) + +{- | +/No description available in the introspection data./ +-} +deploymentNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Int32 + -> T.Text + -> T.Text + -> Int32 + -> T.Text + -> Int32 + -> m Deployment +deploymentNew index osname csum deployserial bootcsum bootserial = liftIO $ do + osname' <- textToCString osname + csum' <- textToCString csum + bootcsum' <- textToCString bootcsum + result <- ostree_deployment_new index osname' csum' deployserial bootcsum' bootserial + checkUnexpectedReturnNULL "deploymentNew" result + result' <- (wrapObject Deployment) result + freeMem osname' + freeMem csum' + freeMem bootcsum' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Deployment::clone +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_clone" ostree_deployment_clone :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO (Ptr Deployment) + +{- | +/No description available in the introspection data./ +-} +deploymentClone :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: Deployment -} + -> m Deployment + {- ^ __Returns:__ New deep copy of /@self@/ -} +deploymentClone self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_clone self' + checkUnexpectedReturnNULL "deploymentClone" result + result' <- (wrapObject Deployment) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentCloneMethodInfo +instance (signature ~ (m Deployment), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentCloneMethodInfo a signature where + overloadedMethod _ = deploymentClone + +#endif + +-- method Deployment::equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ap", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bp", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_equal" ostree_deployment_equal :: + Ptr Deployment -> -- ap : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr Deployment -> -- bp : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +deploymentEqual :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a, IsDeployment b) => + a + {- ^ /@ap@/: A deployment -} + -> b + {- ^ /@bp@/: A deployment -} + -> m Bool + {- ^ __Returns:__ 'True' if deployments have the same osname, csum, and deployserial -} +deploymentEqual ap bp = liftIO $ do + ap' <- unsafeManagedPtrCastPtr ap + bp' <- unsafeManagedPtrCastPtr bp + result <- ostree_deployment_equal ap' bp' + let result' = (/= 0) result + touchManagedPtr ap + touchManagedPtr bp + return result' + +#if ENABLE_OVERLOADING +data DeploymentEqualMethodInfo +instance (signature ~ (b -> m Bool), MonadIO m, IsDeployment a, IsDeployment b) => O.MethodInfo DeploymentEqualMethodInfo a signature where + overloadedMethod _ = deploymentEqual + +#endif + +-- method Deployment::get_bootconfig +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "BootconfigParser"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_bootconfig" ostree_deployment_get_bootconfig :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO (Ptr OSTree.BootconfigParser.BootconfigParser) + +{- | +/No description available in the introspection data./ +-} +deploymentGetBootconfig :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: Deployment -} + -> m OSTree.BootconfigParser.BootconfigParser + {- ^ __Returns:__ Boot configuration -} +deploymentGetBootconfig self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_bootconfig self' + checkUnexpectedReturnNULL "deploymentGetBootconfig" result + result' <- (newObject OSTree.BootconfigParser.BootconfigParser) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetBootconfigMethodInfo +instance (signature ~ (m OSTree.BootconfigParser.BootconfigParser), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetBootconfigMethodInfo a signature where + overloadedMethod _ = deploymentGetBootconfig + +#endif + +-- method Deployment::get_bootcsum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_bootcsum" ostree_deployment_get_bootcsum :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +deploymentGetBootcsum :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m T.Text +deploymentGetBootcsum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_bootcsum self' + checkUnexpectedReturnNULL "deploymentGetBootcsum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetBootcsumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetBootcsumMethodInfo a signature where + overloadedMethod _ = deploymentGetBootcsum + +#endif + +-- method Deployment::get_bootserial +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_bootserial" ostree_deployment_get_bootserial :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +deploymentGetBootserial :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m Int32 +deploymentGetBootserial self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_bootserial self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data DeploymentGetBootserialMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetBootserialMethodInfo a signature where + overloadedMethod _ = deploymentGetBootserial + +#endif + +-- method Deployment::get_csum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_csum" ostree_deployment_get_csum :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +deploymentGetCsum :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m T.Text +deploymentGetCsum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_csum self' + checkUnexpectedReturnNULL "deploymentGetCsum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetCsumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetCsumMethodInfo a signature where + overloadedMethod _ = deploymentGetCsum + +#endif + +-- method Deployment::get_deployserial +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_deployserial" ostree_deployment_get_deployserial :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +deploymentGetDeployserial :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m Int32 +deploymentGetDeployserial self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_deployserial self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data DeploymentGetDeployserialMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetDeployserialMethodInfo a signature where + overloadedMethod _ = deploymentGetDeployserial + +#endif + +-- method Deployment::get_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_index" ostree_deployment_get_index :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +deploymentGetIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m Int32 +deploymentGetIndex self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_index self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data DeploymentGetIndexMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetIndexMethodInfo a signature where + overloadedMethod _ = deploymentGetIndex + +#endif + +-- method Deployment::get_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_origin" ostree_deployment_get_origin :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +deploymentGetOrigin :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: Deployment -} + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ Origin -} +deploymentGetOrigin self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_origin self' + checkUnexpectedReturnNULL "deploymentGetOrigin" result + result' <- (newBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetOriginMethodInfo +instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetOriginMethodInfo a signature where + overloadedMethod _ = deploymentGetOrigin + +#endif + +-- method Deployment::get_origin_relpath +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_origin_relpath" ostree_deployment_get_origin_relpath :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CString + +{- | +Note this function only returns a *relative* path - if you want to +access, it, you must either use fd-relative api such as @/openat()/@, +or concatenate it with the full 'GI.OSTree.Objects.Sysroot.sysrootGetPath'. +-} +deploymentGetOriginRelpath :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: A deployment -} + -> m T.Text + {- ^ __Returns:__ Path to deployment root directory, relative to sysroot -} +deploymentGetOriginRelpath self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_origin_relpath self' + checkUnexpectedReturnNULL "deploymentGetOriginRelpath" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetOriginRelpathMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetOriginRelpathMethodInfo a signature where + overloadedMethod _ = deploymentGetOriginRelpath + +#endif + +-- method Deployment::get_osname +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_osname" ostree_deployment_get_osname :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +deploymentGetOsname :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m T.Text +deploymentGetOsname self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_osname self' + checkUnexpectedReturnNULL "deploymentGetOsname" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetOsnameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetOsnameMethodInfo a signature where + overloadedMethod _ = deploymentGetOsname + +#endif + +-- method Deployment::get_unlocked +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_get_unlocked" ostree_deployment_get_unlocked :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CUInt + +{- | +/No description available in the introspection data./ +-} +deploymentGetUnlocked :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> m OSTree.Enums.DeploymentUnlockedState +deploymentGetUnlocked self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_get_unlocked self' + let result' = (toEnum . fromIntegral) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentGetUnlockedMethodInfo +instance (signature ~ (m OSTree.Enums.DeploymentUnlockedState), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentGetUnlockedMethodInfo a signature where + overloadedMethod _ = deploymentGetUnlocked + +#endif + +-- method Deployment::is_pinned +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_is_pinned" ostree_deployment_is_pinned :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CInt + +{- | +See 'GI.OSTree.Objects.Sysroot.sysrootDeploymentSetPinned'. + +/Since: 2018.3/ +-} +deploymentIsPinned :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: Deployment -} + -> m Bool + {- ^ __Returns:__ @TRUE@ if deployment will not be subject to GC -} +deploymentIsPinned self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_is_pinned self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentIsPinnedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentIsPinnedMethodInfo a signature where + overloadedMethod _ = deploymentIsPinned + +#endif + +-- method Deployment::is_staged +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_is_staged" ostree_deployment_is_staged :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 2018.3/ +-} +deploymentIsStaged :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + {- ^ /@self@/: Deployment -} + -> m Bool + {- ^ __Returns:__ @TRUE@ if deployment should be \"finalized\" at shutdown time -} +deploymentIsStaged self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_deployment_is_staged self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data DeploymentIsStagedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentIsStagedMethodInfo a signature where + overloadedMethod _ = deploymentIsStaged + +#endif + +-- method Deployment::set_bootconfig +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bootconfig", argType = TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_set_bootconfig" ostree_deployment_set_bootconfig :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr OSTree.BootconfigParser.BootconfigParser -> -- bootconfig : TInterface (Name {namespace = "OSTree", name = "BootconfigParser"}) + IO () + +{- | +/No description available in the introspection data./ +-} +deploymentSetBootconfig :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a, OSTree.BootconfigParser.IsBootconfigParser b) => + a + -> b + -> m () +deploymentSetBootconfig self bootconfig = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + bootconfig' <- unsafeManagedPtrCastPtr bootconfig + ostree_deployment_set_bootconfig self' bootconfig' + touchManagedPtr self + touchManagedPtr bootconfig + return () + +#if ENABLE_OVERLOADING +data DeploymentSetBootconfigMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsDeployment a, OSTree.BootconfigParser.IsBootconfigParser b) => O.MethodInfo DeploymentSetBootconfigMethodInfo a signature where + overloadedMethod _ = deploymentSetBootconfig + +#endif + +-- method Deployment::set_bootserial +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_set_bootserial" ostree_deployment_set_bootserial :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Int32 -> -- index : TBasicType TInt + IO () + +{- | +/No description available in the introspection data./ +-} +deploymentSetBootserial :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> Int32 + -> m () +deploymentSetBootserial self index = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_deployment_set_bootserial self' index + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data DeploymentSetBootserialMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentSetBootserialMethodInfo a signature where + overloadedMethod _ = deploymentSetBootserial + +#endif + +-- method Deployment::set_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_set_index" ostree_deployment_set_index :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Int32 -> -- index : TBasicType TInt + IO () + +{- | +/No description available in the introspection data./ +-} +deploymentSetIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> Int32 + -> m () +deploymentSetIndex self index = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_deployment_set_index self' index + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data DeploymentSetIndexMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentSetIndexMethodInfo a signature where + overloadedMethod _ = deploymentSetIndex + +#endif + +-- method Deployment::set_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_set_origin" ostree_deployment_set_origin :: + Ptr Deployment -> -- self : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr GLib.KeyFile.KeyFile -> -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + IO () + +{- | +/No description available in the introspection data./ +-} +deploymentSetOrigin :: + (B.CallStack.HasCallStack, MonadIO m, IsDeployment a) => + a + -> GLib.KeyFile.KeyFile + -> m () +deploymentSetOrigin self origin = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + origin' <- unsafeManagedPtrGetPtr origin + ostree_deployment_set_origin self' origin' + touchManagedPtr self + touchManagedPtr origin + return () + +#if ENABLE_OVERLOADING +data DeploymentSetOriginMethodInfo +instance (signature ~ (GLib.KeyFile.KeyFile -> m ()), MonadIO m, IsDeployment a) => O.MethodInfo DeploymentSetOriginMethodInfo a signature where + overloadedMethod _ = deploymentSetOrigin + +#endif + +-- method Deployment::hash +-- method type : MemberFunction +-- Args : [Arg {argCName = "v", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_hash" ostree_deployment_hash :: + Ptr () -> -- v : TBasicType TPtr + IO Word32 + +{- | +/No description available in the introspection data./ +-} +deploymentHash :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -> m Word32 +deploymentHash v = liftIO $ do + result <- ostree_deployment_hash v + return result + +#if ENABLE_OVERLOADING +#endif + +-- method Deployment::origin_remove_transient_state +-- method type : MemberFunction +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An origin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_origin_remove_transient_state" ostree_deployment_origin_remove_transient_state :: + Ptr GLib.KeyFile.KeyFile -> -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + IO () + +{- | +The intention of an origin file is primarily describe the \"inputs\" that +resulted in a deployment, and it\'s commonly used to derive the new state. For +example, a key value (in pure libostree mode) is the \"refspec\". However, +libostree (or other applications) may want to store \"transient\" state that +should not be carried across upgrades. + +This function just removes all members of the @libostree-transient@ group. +The name of that group is available to all libostree users; best practice +would be to prefix values underneath there with a short identifier for your +software. + +Additionally, this function will remove the @origin\/unlocked@ and +@origin\/override-commit@ members; these should be considered transient state +that should have been under an explicit group. + +/Since: 2018.3/ +-} +deploymentOriginRemoveTransientState :: + (B.CallStack.HasCallStack, MonadIO m) => + GLib.KeyFile.KeyFile + {- ^ /@origin@/: An origin -} + -> m () +deploymentOriginRemoveTransientState origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + ostree_deployment_origin_remove_transient_state origin' + touchManagedPtr origin + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Deployment::unlocked_state_to_string +-- method type : MemberFunction +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_deployment_unlocked_state_to_string" ostree_deployment_unlocked_state_to_string :: + CUInt -> -- state : TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +deploymentUnlockedStateToString :: + (B.CallStack.HasCallStack, MonadIO m) => + OSTree.Enums.DeploymentUnlockedState + -> m T.Text +deploymentUnlockedStateToString state = liftIO $ do + let state' = (fromIntegral . fromEnum) state + result <- ostree_deployment_unlocked_state_to_string state' + checkUnexpectedReturnNULL "deploymentUnlockedStateToString" result + result' <- cstringToText result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/Deployment.hs-boot b/GI/OSTree/Objects/Deployment.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Deployment.hs-boot @@ -0,0 +1,83 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.Deployment 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype Deployment = Deployment (ManagedPtr Deployment) +instance GObject Deployment where +class (GObject o, O.IsDescendantOf Deployment o) => IsDeployment o +instance (GObject o, O.IsDescendantOf Deployment o) => IsDeployment o +instance O.HasParentTypes Deployment +#if ENABLE_OVERLOADING +data DeploymentCloneMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetBootconfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetBootcsumMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetBootserialMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetCsumMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetDeployserialMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetOriginMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetOriginRelpathMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetOsnameMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentGetUnlockedMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentIsPinnedMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentIsStagedMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentSetBootconfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentSetBootserialMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentSetIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data DeploymentSetOriginMethodInfo +#endif diff --git a/GI/OSTree/Objects/GpgVerifyResult.hs b/GI/OSTree/Objects/GpgVerifyResult.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/GpgVerifyResult.hs @@ -0,0 +1,584 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.GpgVerifyResult + ( + +-- * Exported types + GpgVerifyResult(..) , + IsGpgVerifyResult , + toGpgVerifyResult , + noGpgVerifyResult , + + + -- * Methods +-- ** countAll #method:countAll# + +#if ENABLE_OVERLOADING + GpgVerifyResultCountAllMethodInfo , +#endif + gpgVerifyResultCountAll , + + +-- ** countValid #method:countValid# + +#if ENABLE_OVERLOADING + GpgVerifyResultCountValidMethodInfo , +#endif + gpgVerifyResultCountValid , + + +-- ** describe #method:describe# + +#if ENABLE_OVERLOADING + GpgVerifyResultDescribeMethodInfo , +#endif + gpgVerifyResultDescribe , + + +-- ** describeVariant #method:describeVariant# + + gpgVerifyResultDescribeVariant , + + +-- ** get #method:get# + +#if ENABLE_OVERLOADING + GpgVerifyResultGetMethodInfo , +#endif + gpgVerifyResultGet , + + +-- ** getAll #method:getAll# + +#if ENABLE_OVERLOADING + GpgVerifyResultGetAllMethodInfo , +#endif + gpgVerifyResultGetAll , + + +-- ** lookup #method:lookup# + +#if ENABLE_OVERLOADING + GpgVerifyResultLookupMethodInfo , +#endif + gpgVerifyResultLookup , + + +-- ** requireValidSignature #method:requireValidSignature# + +#if ENABLE_OVERLOADING + GpgVerifyResultRequireValidSignatureMethodInfo, +#endif + gpgVerifyResultRequireValidSignature , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.String as GLib.String +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.Initable as Gio.Initable +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums + +-- | Memory-managed wrapper type. +newtype GpgVerifyResult = GpgVerifyResult (ManagedPtr GpgVerifyResult) +foreign import ccall "ostree_gpg_verify_result_get_type" + c_ostree_gpg_verify_result_get_type :: IO GType + +instance GObject GpgVerifyResult where + gobjectType = c_ostree_gpg_verify_result_get_type + + +-- | Type class for types which can be safely cast to `GpgVerifyResult`, for instance with `toGpgVerifyResult`. +class (GObject o, O.IsDescendantOf GpgVerifyResult o) => IsGpgVerifyResult o +instance (GObject o, O.IsDescendantOf GpgVerifyResult o) => IsGpgVerifyResult o + +instance O.HasParentTypes GpgVerifyResult +type instance O.ParentTypes GpgVerifyResult = '[GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `GpgVerifyResult`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGpgVerifyResult :: (MonadIO m, IsGpgVerifyResult o) => o -> m GpgVerifyResult +toGpgVerifyResult = liftIO . unsafeCastTo GpgVerifyResult + +-- | A convenience alias for `Nothing` :: `Maybe` `GpgVerifyResult`. +noGpgVerifyResult :: Maybe GpgVerifyResult +noGpgVerifyResult = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGpgVerifyResultMethod (t :: Symbol) (o :: *) :: * where + ResolveGpgVerifyResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGpgVerifyResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGpgVerifyResultMethod "countAll" o = GpgVerifyResultCountAllMethodInfo + ResolveGpgVerifyResultMethod "countValid" o = GpgVerifyResultCountValidMethodInfo + ResolveGpgVerifyResultMethod "describe" o = GpgVerifyResultDescribeMethodInfo + ResolveGpgVerifyResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGpgVerifyResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGpgVerifyResultMethod "get" o = GpgVerifyResultGetMethodInfo + ResolveGpgVerifyResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGpgVerifyResultMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveGpgVerifyResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGpgVerifyResultMethod "lookup" o = GpgVerifyResultLookupMethodInfo + ResolveGpgVerifyResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGpgVerifyResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGpgVerifyResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGpgVerifyResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGpgVerifyResultMethod "requireValidSignature" o = GpgVerifyResultRequireValidSignatureMethodInfo + ResolveGpgVerifyResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGpgVerifyResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGpgVerifyResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGpgVerifyResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGpgVerifyResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGpgVerifyResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGpgVerifyResultMethod "getAll" o = GpgVerifyResultGetAllMethodInfo + ResolveGpgVerifyResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGpgVerifyResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGpgVerifyResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGpgVerifyResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGpgVerifyResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGpgVerifyResultMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGpgVerifyResultMethod t GpgVerifyResult, O.MethodInfo info GpgVerifyResult p) => OL.IsLabel t (GpgVerifyResult -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GpgVerifyResult +type instance O.AttributeList GpgVerifyResult = GpgVerifyResultAttributeList +type GpgVerifyResultAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList GpgVerifyResult = GpgVerifyResultSignalList +type GpgVerifyResultSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method GpgVerifyResult::count_all +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_count_all" ostree_gpg_verify_result_count_all :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + IO Word32 + +{- | +Counts all the signatures in /@result@/. +-} +gpgVerifyResultCountAll :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> m Word32 + {- ^ __Returns:__ signature count -} +gpgVerifyResultCountAll result_ = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + result <- ostree_gpg_verify_result_count_all result_' + touchManagedPtr result_ + return result + +#if ENABLE_OVERLOADING +data GpgVerifyResultCountAllMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultCountAllMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultCountAll + +#endif + +-- method GpgVerifyResult::count_valid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_count_valid" ostree_gpg_verify_result_count_valid :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + IO Word32 + +{- | +Counts only the valid signatures in /@result@/. +-} +gpgVerifyResultCountValid :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> m Word32 + {- ^ __Returns:__ valid signature count -} +gpgVerifyResultCountValid result_ = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + result <- ostree_gpg_verify_result_count_valid result_' + touchManagedPtr result_ + return result + +#if ENABLE_OVERLOADING +data GpgVerifyResultCountValidMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultCountValidMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultCountValid + +#endif + +-- method GpgVerifyResult::describe +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "which signature to describe", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "output_buffer", argType = TInterface (Name {namespace = "GLib", name = "String"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GString to hold the description", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional line prefix string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "GpgSignatureFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to adjust the description format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_describe" ostree_gpg_verify_result_describe :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + Word32 -> -- signature_index : TBasicType TUInt + Ptr GLib.String.String -> -- output_buffer : TInterface (Name {namespace = "GLib", name = "String"}) + CString -> -- line_prefix : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "GpgSignatureFormatFlags"}) + IO () + +{- | +Appends a brief, human-readable description of the GPG signature at +/@signatureIndex@/ in /@result@/ to the /@outputBuffer@/. The description +spans multiple lines. A /@linePrefix@/ string, if given, will precede +each line of the description. + +The /@flags@/ argument is reserved for future variations to the description +format. Currently must be 0. + +It is a programmer error to request an invalid /@signatureIndex@/. Use +'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultCountAll' to find the number of signatures in +/@result@/. +-} +gpgVerifyResultDescribe :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> Word32 + {- ^ /@signatureIndex@/: which signature to describe -} + -> GLib.String.String + {- ^ /@outputBuffer@/: a 'GI.GLib.Structs.String.String' to hold the description -} + -> Maybe (T.Text) + {- ^ /@linePrefix@/: optional line prefix string -} + -> OSTree.Enums.GpgSignatureFormatFlags + {- ^ /@flags@/: flags to adjust the description format -} + -> m () +gpgVerifyResultDescribe result_ signatureIndex outputBuffer linePrefix flags = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + outputBuffer' <- unsafeManagedPtrGetPtr outputBuffer + maybeLinePrefix <- case linePrefix of + Nothing -> return nullPtr + Just jLinePrefix -> do + jLinePrefix' <- textToCString jLinePrefix + return jLinePrefix' + let flags' = (fromIntegral . fromEnum) flags + ostree_gpg_verify_result_describe result_' signatureIndex outputBuffer' maybeLinePrefix flags' + touchManagedPtr result_ + touchManagedPtr outputBuffer + freeMem maybeLinePrefix + return () + +#if ENABLE_OVERLOADING +data GpgVerifyResultDescribeMethodInfo +instance (signature ~ (Word32 -> GLib.String.String -> Maybe (T.Text) -> OSTree.Enums.GpgSignatureFormatFlags -> m ()), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultDescribeMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultDescribe + +#endif + +-- method GpgVerifyResult::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "which signature to get attributes from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attrs", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "OSTree", name = "GpgSignatureAttr"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Array of requested attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_attrs", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of the @attrs array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_attrs", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of the @attrs array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_get" ostree_gpg_verify_result_get :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + Word32 -> -- signature_index : TBasicType TUInt + Ptr CUInt -> -- attrs : TCArray False (-1) 3 (TInterface (Name {namespace = "OSTree", name = "GpgSignatureAttr"})) + Word32 -> -- n_attrs : TBasicType TUInt + IO (Ptr GVariant) + +{- | +Builds a 'GVariant' tuple of requested attributes for the GPG signature at +/@signatureIndex@/ in /@result@/. See the 'GI.OSTree.Enums.GpgSignatureAttr' description +for the 'GI.GLib.Structs.VariantType.VariantType' of each available attribute. + +It is a programmer error to request an invalid 'GI.OSTree.Enums.GpgSignatureAttr' or +an invalid /@signatureIndex@/. Use 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultCountAll' to +find the number of signatures in /@result@/. +-} +gpgVerifyResultGet :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> Word32 + {- ^ /@signatureIndex@/: which signature to get attributes from -} + -> [OSTree.Enums.GpgSignatureAttr] + {- ^ /@attrs@/: Array of requested attributes -} + -> m GVariant + {- ^ __Returns:__ a new, floating, 'GVariant' tuple -} +gpgVerifyResultGet result_ signatureIndex attrs = liftIO $ do + let nAttrs = fromIntegral $ length attrs + result_' <- unsafeManagedPtrCastPtr result_ + let attrs' = map (fromIntegral . fromEnum) attrs + attrs'' <- packStorableArray attrs' + result <- ostree_gpg_verify_result_get result_' signatureIndex attrs'' nAttrs + checkUnexpectedReturnNULL "gpgVerifyResultGet" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr result_ + freeMem attrs'' + return result' + +#if ENABLE_OVERLOADING +data GpgVerifyResultGetMethodInfo +instance (signature ~ (Word32 -> [OSTree.Enums.GpgSignatureAttr] -> m GVariant), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultGetMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultGet + +#endif + +-- method GpgVerifyResult::get_all +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "which signature to get attributes from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_get_all" ostree_gpg_verify_result_get_all :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + Word32 -> -- signature_index : TBasicType TUInt + IO (Ptr GVariant) + +{- | +Builds a 'GVariant' tuple of all available attributes for the GPG signature +at /@signatureIndex@/ in /@result@/. + +The child values in the returned 'GVariant' tuple are ordered to match the +'GI.OSTree.Enums.GpgSignatureAttr' enumeration, which means the enum values can be +used as index values in functions like @/g_variant_get_child()/@. See the +'GI.OSTree.Enums.GpgSignatureAttr' description for the 'GI.GLib.Structs.VariantType.VariantType' of each +available attribute. + +\ + \ + The 'GI.OSTree.Enums.GpgSignatureAttr' enumeration may be extended in the future + with new attributes, which would affect the 'GVariant' tuple returned by + this function. While the position and type of current child values in + the 'GVariant' tuple will not change, to avoid backward-compatibility + issues \please do not depend on the tuple\'s overall size or + type signature\<\/emphasis>. + \<\/para> +\<\/note> + +It is a programmer error to request an invalid /@signatureIndex@/. Use +'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultCountAll' to find the number of signatures in +/@result@/. +-} +gpgVerifyResultGetAll :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> Word32 + {- ^ /@signatureIndex@/: which signature to get attributes from -} + -> m GVariant + {- ^ __Returns:__ a new, floating, 'GVariant' tuple -} +gpgVerifyResultGetAll result_ signatureIndex = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + result <- ostree_gpg_verify_result_get_all result_' signatureIndex + checkUnexpectedReturnNULL "gpgVerifyResultGetAll" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr result_ + return result' + +#if ENABLE_OVERLOADING +data GpgVerifyResultGetAllMethodInfo +instance (signature ~ (Word32 -> m GVariant), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultGetAllMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultGetAll + +#endif + +-- method GpgVerifyResult::lookup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GPG key ID or fingerprint", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_signature_index", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the index of the signature\n signed by @key_id, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_lookup" ostree_gpg_verify_result_lookup :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + CString -> -- key_id : TBasicType TUTF8 + Ptr Word32 -> -- out_signature_index : TBasicType TUInt + IO CInt + +{- | +Searches /@result@/ for a signature signed by /@keyId@/. If a match is found, +the function returns 'True' and sets /@outSignatureIndex@/ so that further +signature details can be obtained through 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultGet'. +If no match is found, the function returns 'False' and leaves +/@outSignatureIndex@/ unchanged. +-} +gpgVerifyResultLookup :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> T.Text + {- ^ /@keyId@/: a GPG key ID or fingerprint -} + -> m ((Bool, Word32)) + {- ^ __Returns:__ 'True' on success, 'False' on failure -} +gpgVerifyResultLookup result_ keyId = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + keyId' <- textToCString keyId + outSignatureIndex <- allocMem :: IO (Ptr Word32) + result <- ostree_gpg_verify_result_lookup result_' keyId' outSignatureIndex + let result' = (/= 0) result + outSignatureIndex' <- peek outSignatureIndex + touchManagedPtr result_ + freeMem keyId' + freeMem outSignatureIndex + return (result', outSignatureIndex') + +#if ENABLE_OVERLOADING +data GpgVerifyResultLookupMethodInfo +instance (signature ~ (T.Text -> m ((Bool, Word32))), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultLookupMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultLookup + +#endif + +-- method GpgVerifyResult::require_valid_signature +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeGpgVerifyResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_require_valid_signature" ostree_gpg_verify_result_require_valid_signature :: + Ptr GpgVerifyResult -> -- result : TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Checks if the result contains at least one signature from the +trusted keyring. You can call this function immediately after +'GI.OSTree.Objects.Repo.repoVerifySummary' or 'GI.OSTree.Objects.Repo.repoVerifyCommitExt' - +it will handle the 'Nothing' /@result@/ and filled /@error@/ too. +-} +gpgVerifyResultRequireValidSignature :: + (B.CallStack.HasCallStack, MonadIO m, IsGpgVerifyResult a) => + a + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +gpgVerifyResultRequireValidSignature result_ = liftIO $ do + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ ostree_gpg_verify_result_require_valid_signature result_' + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data GpgVerifyResultRequireValidSignatureMethodInfo +instance (signature ~ (m ()), MonadIO m, IsGpgVerifyResult a) => O.MethodInfo GpgVerifyResultRequireValidSignatureMethodInfo a signature where + overloadedMethod _ = gpgVerifyResultRequireValidSignature + +#endif + +-- method GpgVerifyResult::describe_variant +-- method type : MemberFunction +-- Args : [Arg {argCName = "variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVariant from ostree_gpg_verify_result_get_all()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "output_buffer", argType = TInterface (Name {namespace = "GLib", name = "String"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GString to hold the description", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional line prefix string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "GpgSignatureFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to adjust the description format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_gpg_verify_result_describe_variant" ostree_gpg_verify_result_describe_variant :: + Ptr GVariant -> -- variant : TVariant + Ptr GLib.String.String -> -- output_buffer : TInterface (Name {namespace = "GLib", name = "String"}) + CString -> -- line_prefix : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "GpgSignatureFormatFlags"}) + IO () + +{- | +Similar to 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultDescribe' but takes a 'GVariant' of +all attributes for a GPG signature instead of an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' +and signature index. + +The /@variant@/ \MUST\<\/emphasis> have been created by +'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultGetAll'. +-} +gpgVerifyResultDescribeVariant :: + (B.CallStack.HasCallStack, MonadIO m) => + GVariant + {- ^ /@variant@/: a 'GVariant' from 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultGetAll' -} + -> GLib.String.String + {- ^ /@outputBuffer@/: a 'GI.GLib.Structs.String.String' to hold the description -} + -> Maybe (T.Text) + {- ^ /@linePrefix@/: optional line prefix string -} + -> OSTree.Enums.GpgSignatureFormatFlags + {- ^ /@flags@/: flags to adjust the description format -} + -> m () +gpgVerifyResultDescribeVariant variant outputBuffer linePrefix flags = liftIO $ do + variant' <- unsafeManagedPtrGetPtr variant + outputBuffer' <- unsafeManagedPtrGetPtr outputBuffer + maybeLinePrefix <- case linePrefix of + Nothing -> return nullPtr + Just jLinePrefix -> do + jLinePrefix' <- textToCString jLinePrefix + return jLinePrefix' + let flags' = (fromIntegral . fromEnum) flags + ostree_gpg_verify_result_describe_variant variant' outputBuffer' maybeLinePrefix flags' + touchManagedPtr variant + touchManagedPtr outputBuffer + freeMem maybeLinePrefix + return () + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/GpgVerifyResult.hs-boot b/GI/OSTree/Objects/GpgVerifyResult.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/GpgVerifyResult.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.GpgVerifyResult 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype GpgVerifyResult = GpgVerifyResult (ManagedPtr GpgVerifyResult) +instance GObject GpgVerifyResult where +class (GObject o, O.IsDescendantOf GpgVerifyResult o) => IsGpgVerifyResult o +instance (GObject o, O.IsDescendantOf GpgVerifyResult o) => IsGpgVerifyResult o +instance O.HasParentTypes GpgVerifyResult +#if ENABLE_OVERLOADING +data GpgVerifyResultCountAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultCountValidMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultDescribeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultGetAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultLookupMethodInfo +#endif +#if ENABLE_OVERLOADING +data GpgVerifyResultRequireValidSignatureMethodInfo +#endif diff --git a/GI/OSTree/Objects/MutableTree.hs b/GI/OSTree/Objects/MutableTree.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/MutableTree.hs @@ -0,0 +1,928 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Private instance structure. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.MutableTree + ( +#if ENABLE_OVERLOADING + MutableTreeGetSubdirsMethodInfo , +#endif + +-- * Exported types + MutableTree(..) , + IsMutableTree , + toMutableTree , + noMutableTree , + + + -- * Methods +-- ** checkError #method:checkError# + +#if ENABLE_OVERLOADING + MutableTreeCheckErrorMethodInfo , +#endif + mutableTreeCheckError , + + +-- ** ensureDir #method:ensureDir# + +#if ENABLE_OVERLOADING + MutableTreeEnsureDirMethodInfo , +#endif + mutableTreeEnsureDir , + + +-- ** ensureParentDirs #method:ensureParentDirs# + +#if ENABLE_OVERLOADING + MutableTreeEnsureParentDirsMethodInfo , +#endif + mutableTreeEnsureParentDirs , + + +-- ** fillEmptyFromDirtree #method:fillEmptyFromDirtree# + +#if ENABLE_OVERLOADING + MutableTreeFillEmptyFromDirtreeMethodInfo, +#endif + mutableTreeFillEmptyFromDirtree , + + +-- ** getContentsChecksum #method:getContentsChecksum# + +#if ENABLE_OVERLOADING + MutableTreeGetContentsChecksumMethodInfo, +#endif + mutableTreeGetContentsChecksum , + + +-- ** getFiles #method:getFiles# + +#if ENABLE_OVERLOADING + MutableTreeGetFilesMethodInfo , +#endif + mutableTreeGetFiles , + + +-- ** getMetadataChecksum #method:getMetadataChecksum# + +#if ENABLE_OVERLOADING + MutableTreeGetMetadataChecksumMethodInfo, +#endif + mutableTreeGetMetadataChecksum , + + +-- ** lookup #method:lookup# + +#if ENABLE_OVERLOADING + MutableTreeLookupMethodInfo , +#endif + mutableTreeLookup , + + +-- ** new #method:new# + + mutableTreeNew , + + +-- ** newFromChecksum #method:newFromChecksum# + + mutableTreeNewFromChecksum , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + MutableTreeRemoveMethodInfo , +#endif + mutableTreeRemove , + + +-- ** replaceFile #method:replaceFile# + +#if ENABLE_OVERLOADING + MutableTreeReplaceFileMethodInfo , +#endif + mutableTreeReplaceFile , + + +-- ** setContentsChecksum #method:setContentsChecksum# + +#if ENABLE_OVERLOADING + MutableTreeSetContentsChecksumMethodInfo, +#endif + mutableTreeSetContentsChecksum , + + +-- ** setMetadataChecksum #method:setMetadataChecksum# + +#if ENABLE_OVERLOADING + MutableTreeSetMetadataChecksumMethodInfo, +#endif + mutableTreeSetMetadataChecksum , + + +-- ** walk #method:walk# + +#if ENABLE_OVERLOADING + MutableTreeWalkMethodInfo , +#endif + mutableTreeWalk , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo + +-- | Memory-managed wrapper type. +newtype MutableTree = MutableTree (ManagedPtr MutableTree) +foreign import ccall "ostree_mutable_tree_get_type" + c_ostree_mutable_tree_get_type :: IO GType + +instance GObject MutableTree where + gobjectType = c_ostree_mutable_tree_get_type + + +-- | Type class for types which can be safely cast to `MutableTree`, for instance with `toMutableTree`. +class (GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o +instance (GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o + +instance O.HasParentTypes MutableTree +type instance O.ParentTypes MutableTree = '[GObject.Object.Object] + +-- | Cast to `MutableTree`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMutableTree :: (MonadIO m, IsMutableTree o) => o -> m MutableTree +toMutableTree = liftIO . unsafeCastTo MutableTree + +-- | A convenience alias for `Nothing` :: `Maybe` `MutableTree`. +noMutableTree :: Maybe MutableTree +noMutableTree = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMutableTreeMethod (t :: Symbol) (o :: *) :: * where + ResolveMutableTreeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMutableTreeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMutableTreeMethod "checkError" o = MutableTreeCheckErrorMethodInfo + ResolveMutableTreeMethod "ensureDir" o = MutableTreeEnsureDirMethodInfo + ResolveMutableTreeMethod "ensureParentDirs" o = MutableTreeEnsureParentDirsMethodInfo + ResolveMutableTreeMethod "fillEmptyFromDirtree" o = MutableTreeFillEmptyFromDirtreeMethodInfo + ResolveMutableTreeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMutableTreeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMutableTreeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMutableTreeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMutableTreeMethod "lookup" o = MutableTreeLookupMethodInfo + ResolveMutableTreeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMutableTreeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMutableTreeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMutableTreeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMutableTreeMethod "remove" o = MutableTreeRemoveMethodInfo + ResolveMutableTreeMethod "replaceFile" o = MutableTreeReplaceFileMethodInfo + ResolveMutableTreeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMutableTreeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMutableTreeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMutableTreeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMutableTreeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMutableTreeMethod "walk" o = MutableTreeWalkMethodInfo + ResolveMutableTreeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMutableTreeMethod "getContentsChecksum" o = MutableTreeGetContentsChecksumMethodInfo + ResolveMutableTreeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMutableTreeMethod "getFiles" o = MutableTreeGetFilesMethodInfo + ResolveMutableTreeMethod "getMetadataChecksum" o = MutableTreeGetMetadataChecksumMethodInfo + ResolveMutableTreeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMutableTreeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMutableTreeMethod "getSubdirs" o = MutableTreeGetSubdirsMethodInfo + ResolveMutableTreeMethod "setContentsChecksum" o = MutableTreeSetContentsChecksumMethodInfo + ResolveMutableTreeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMutableTreeMethod "setMetadataChecksum" o = MutableTreeSetMetadataChecksumMethodInfo + ResolveMutableTreeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMutableTreeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMutableTreeMethod t MutableTree, O.MethodInfo info MutableTree p) => OL.IsLabel t (MutableTree -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList MutableTree +type instance O.AttributeList MutableTree = MutableTreeAttributeList +type MutableTreeAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList MutableTree = MutableTreeSignalList +type MutableTreeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method MutableTree::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "MutableTree"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_new" ostree_mutable_tree_new :: + IO (Ptr MutableTree) + +{- | +/No description available in the introspection data./ +-} +mutableTreeNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m MutableTree + {- ^ __Returns:__ A new tree -} +mutableTreeNew = liftIO $ do + result <- ostree_mutable_tree_new + checkUnexpectedReturnNULL "mutableTreeNew" result + result' <- (wrapObject MutableTree) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method MutableTree::new_from_checksum +-- method type : Constructor +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The repo which contains the objects refered by the checksums.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "contents_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "dirtree checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "dirmeta checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "MutableTree"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_new_from_checksum" ostree_mutable_tree_new_from_checksum :: + Ptr OSTree.Repo.Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- contents_checksum : TBasicType TUTF8 + CString -> -- metadata_checksum : TBasicType TUTF8 + IO (Ptr MutableTree) + +{- | +Creates a new OstreeMutableTree with the contents taken from the given repo +and checksums. The data will be loaded from the repo lazily as needed. +-} +mutableTreeNewFromChecksum :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + a + {- ^ /@repo@/: The repo which contains the objects refered by the checksums. -} + -> T.Text + {- ^ /@contentsChecksum@/: dirtree checksum -} + -> T.Text + {- ^ /@metadataChecksum@/: dirmeta checksum -} + -> m MutableTree + {- ^ __Returns:__ A new tree -} +mutableTreeNewFromChecksum repo contentsChecksum metadataChecksum = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + contentsChecksum' <- textToCString contentsChecksum + metadataChecksum' <- textToCString metadataChecksum + result <- ostree_mutable_tree_new_from_checksum repo' contentsChecksum' metadataChecksum' + checkUnexpectedReturnNULL "mutableTreeNewFromChecksum" result + result' <- (wrapObject MutableTree) result + touchManagedPtr repo + freeMem contentsChecksum' + freeMem metadataChecksum' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method MutableTree::check_error +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_check_error" ostree_mutable_tree_check_error :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +In some cases, a tree may be in a \"lazy\" state that loads +data in the background; if an error occurred during a non-throwing +API call, it will have been cached. This function checks for a +cached error. The tree remains in error state. + +/Since: 2018.7/ +-} +mutableTreeCheckError :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + {- ^ /@self@/: Tree -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeCheckError self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ ostree_mutable_tree_check_error self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data MutableTreeCheckErrorMethodInfo +instance (signature ~ (m ()), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeCheckErrorMethodInfo a signature where + overloadedMethod _ = mutableTreeCheckError + +#endif + +-- method MutableTree::ensure_dir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of subdirectory of self to retrieve/creates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_subdir", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the subdirectory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_ensure_dir" ostree_mutable_tree_ensure_dir :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr MutableTree) -> -- out_subdir : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Returns the subdirectory of self with filename /@name@/, creating an empty one +it if it doesn\'t exist. +-} +mutableTreeEnsureDir :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + {- ^ /@self@/: Tree -} + -> T.Text + {- ^ /@name@/: Name of subdirectory of self to retrieve\/creates -} + -> m (MutableTree) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeEnsureDir self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outSubdir <- allocMem :: IO (Ptr (Ptr MutableTree)) + onException (do + _ <- propagateGError $ ostree_mutable_tree_ensure_dir self' name' outSubdir + outSubdir' <- peek outSubdir + outSubdir'' <- (wrapObject MutableTree) outSubdir' + touchManagedPtr self + freeMem name' + freeMem outSubdir + return outSubdir'' + ) (do + freeMem name' + freeMem outSubdir + ) + +#if ENABLE_OVERLOADING +data MutableTreeEnsureDirMethodInfo +instance (signature ~ (T.Text -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeEnsureDirMethodInfo a signature where + overloadedMethod _ = mutableTreeEnsureDir + +#endif + +-- method MutableTree::ensure_parent_dirs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "split_path", argType = TPtrArray (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File path components", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "SHA256 checksum for metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_parent", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The parent tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_ensure_parent_dirs" ostree_mutable_tree_ensure_parent_dirs :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (GPtrArray CString) -> -- split_path : TPtrArray (TBasicType TUTF8) + CString -> -- metadata_checksum : TBasicType TUTF8 + Ptr (Ptr MutableTree) -> -- out_parent : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Create all parent trees necessary for the given /@splitPath@/ to +exist. +-} +mutableTreeEnsureParentDirs :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + {- ^ /@self@/: Tree -} + -> [T.Text] + {- ^ /@splitPath@/: File path components -} + -> T.Text + {- ^ /@metadataChecksum@/: SHA256 checksum for metadata -} + -> m (MutableTree) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeEnsureParentDirs self splitPath metadataChecksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + splitPath' <- mapM textToCString splitPath + splitPath'' <- packGPtrArray splitPath' + metadataChecksum' <- textToCString metadataChecksum + outParent <- allocMem :: IO (Ptr (Ptr MutableTree)) + onException (do + _ <- propagateGError $ ostree_mutable_tree_ensure_parent_dirs self' splitPath'' metadataChecksum' outParent + outParent' <- peek outParent + outParent'' <- (wrapObject MutableTree) outParent' + touchManagedPtr self + mapPtrArray freeMem splitPath'' + unrefPtrArray splitPath'' + freeMem metadataChecksum' + freeMem outParent + return outParent'' + ) (do + mapPtrArray freeMem splitPath'' + unrefPtrArray splitPath'' + freeMem metadataChecksum' + freeMem outParent + ) + +#if ENABLE_OVERLOADING +data MutableTreeEnsureParentDirsMethodInfo +instance (signature ~ ([T.Text] -> T.Text -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeEnsureParentDirsMethodInfo a signature where + overloadedMethod _ = mutableTreeEnsureParentDirs + +#endif + +-- method MutableTree::fill_empty_from_dirtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "contents_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_fill_empty_from_dirtree" ostree_mutable_tree_fill_empty_from_dirtree :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr OSTree.Repo.Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- contents_checksum : TBasicType TUTF8 + CString -> -- metadata_checksum : TBasicType TUTF8 + IO CInt + +{- | +Merges /@self@/ with the tree given by /@contentsChecksum@/ and +/@metadataChecksum@/, but only if it\'s possible without writing new objects to +the /@repo@/. We can do this if either /@self@/ is empty, the tree given by +/@contentsChecksum@/ is empty or if both trees already have the same +/@contentsChecksum@/. +-} +mutableTreeFillEmptyFromDirtree :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a, OSTree.Repo.IsRepo b) => + a + -> b + -> T.Text + -> T.Text + -> m Bool + {- ^ __Returns:__ /@tRUE@/ if merge was successful, /@fALSE@/ if it was not possible. + +This function enables optimisations when composing trees. The provided +checksums are not loaded or checked when this function is called. Instead +the contents will be loaded only when needed. -} +mutableTreeFillEmptyFromDirtree self repo contentsChecksum metadataChecksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + repo' <- unsafeManagedPtrCastPtr repo + contentsChecksum' <- textToCString contentsChecksum + metadataChecksum' <- textToCString metadataChecksum + result <- ostree_mutable_tree_fill_empty_from_dirtree self' repo' contentsChecksum' metadataChecksum' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr repo + freeMem contentsChecksum' + freeMem metadataChecksum' + return result' + +#if ENABLE_OVERLOADING +data MutableTreeFillEmptyFromDirtreeMethodInfo +instance (signature ~ (b -> T.Text -> T.Text -> m Bool), MonadIO m, IsMutableTree a, OSTree.Repo.IsRepo b) => O.MethodInfo MutableTreeFillEmptyFromDirtreeMethodInfo a signature where + overloadedMethod _ = mutableTreeFillEmptyFromDirtree + +#endif + +-- method MutableTree::get_contents_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_get_contents_checksum" ostree_mutable_tree_get_contents_checksum :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +mutableTreeGetContentsChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> m T.Text +mutableTreeGetContentsChecksum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_mutable_tree_get_contents_checksum self' + checkUnexpectedReturnNULL "mutableTreeGetContentsChecksum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data MutableTreeGetContentsChecksumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeGetContentsChecksumMethodInfo a signature where + overloadedMethod _ = mutableTreeGetContentsChecksum + +#endif + +-- method MutableTree::get_files +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGHash (TBasicType TUTF8) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_get_files" ostree_mutable_tree_get_files :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + IO (Ptr (GHashTable CString CString)) + +{- | +/No description available in the introspection data./ +-} +mutableTreeGetFiles :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> m (Map.Map T.Text T.Text) + {- ^ __Returns:__ All children files (the value is a checksum) -} +mutableTreeGetFiles self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_mutable_tree_get_files self' + checkUnexpectedReturnNULL "mutableTreeGetFiles" result + result' <- unpackGHashTable result + let result'' = mapFirst cstringUnpackPtr result' + result''' <- mapFirstA cstringToText result'' + let result'''' = mapSecond cstringUnpackPtr result''' + result''''' <- mapSecondA cstringToText result'''' + let result'''''' = Map.fromList result''''' + touchManagedPtr self + return result'''''' + +#if ENABLE_OVERLOADING +data MutableTreeGetFilesMethodInfo +instance (signature ~ (m (Map.Map T.Text T.Text)), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeGetFilesMethodInfo a signature where + overloadedMethod _ = mutableTreeGetFiles + +#endif + +-- method MutableTree::get_metadata_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_get_metadata_checksum" ostree_mutable_tree_get_metadata_checksum :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +mutableTreeGetMetadataChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> m T.Text +mutableTreeGetMetadataChecksum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_mutable_tree_get_metadata_checksum self' + checkUnexpectedReturnNULL "mutableTreeGetMetadataChecksum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data MutableTreeGetMetadataChecksumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeGetMetadataChecksumMethodInfo a signature where + overloadedMethod _ = mutableTreeGetMetadataChecksum + +#endif + +-- XXX Could not generate method MutableTree::get_subdirs +-- Error was : Not implemented: "GHashTable element of type TInterface (Name {namespace = \"OSTree\", name = \"MutableTree\"}) unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data MutableTreeGetSubdirsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "getSubdirs" MutableTree) => O.MethodInfo MutableTreeGetSubdirsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method MutableTree::lookup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_file_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_subdir", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_lookup" ostree_mutable_tree_lookup :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- out_file_checksum : TBasicType TUTF8 + Ptr MutableTree -> -- out_subdir : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +mutableTreeLookup :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a, IsMutableTree b) => + a + -> T.Text + -> T.Text + -> b + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeLookup self name outFileChecksum outSubdir = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outFileChecksum' <- textToCString outFileChecksum + outSubdir' <- unsafeManagedPtrCastPtr outSubdir + onException (do + _ <- propagateGError $ ostree_mutable_tree_lookup self' name' outFileChecksum' outSubdir' + touchManagedPtr self + touchManagedPtr outSubdir + freeMem name' + freeMem outFileChecksum' + return () + ) (do + freeMem name' + freeMem outFileChecksum' + ) + +#if ENABLE_OVERLOADING +data MutableTreeLookupMethodInfo +instance (signature ~ (T.Text -> T.Text -> b -> m ()), MonadIO m, IsMutableTree a, IsMutableTree b) => O.MethodInfo MutableTreeLookupMethodInfo a signature where + overloadedMethod _ = mutableTreeLookup + +#endif + +-- method MutableTree::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of file or subdirectory to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_noent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If @FALSE, an error will be thrown if @name does not exist in the tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_remove" ostree_mutable_tree_remove :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- name : TBasicType TUTF8 + CInt -> -- allow_noent : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Remove the file or subdirectory named /@name@/ from the mutable tree /@self@/. +-} +mutableTreeRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + {- ^ /@self@/: Tree -} + -> T.Text + {- ^ /@name@/: Name of file or subdirectory to remove -} + -> Bool + {- ^ /@allowNoent@/: If /@fALSE@/, an error will be thrown if /@name@/ does not exist in the tree -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeRemove self name allowNoent = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + let allowNoent' = (fromIntegral . fromEnum) allowNoent + onException (do + _ <- propagateGError $ ostree_mutable_tree_remove self' name' allowNoent' + touchManagedPtr self + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data MutableTreeRemoveMethodInfo +instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeRemoveMethodInfo a signature where + overloadedMethod _ = mutableTreeRemove + +#endif + +-- method MutableTree::replace_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_replace_file" ostree_mutable_tree_replace_file :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +mutableTreeReplaceFile :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> T.Text + -> T.Text + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeReplaceFile self name checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + checksum' <- textToCString checksum + onException (do + _ <- propagateGError $ ostree_mutable_tree_replace_file self' name' checksum' + touchManagedPtr self + freeMem name' + freeMem checksum' + return () + ) (do + freeMem name' + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data MutableTreeReplaceFileMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeReplaceFileMethodInfo a signature where + overloadedMethod _ = mutableTreeReplaceFile + +#endif + +-- method MutableTree::set_contents_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_set_contents_checksum" ostree_mutable_tree_set_contents_checksum :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- checksum : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +mutableTreeSetContentsChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> T.Text + -> m () +mutableTreeSetContentsChecksum self checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + ostree_mutable_tree_set_contents_checksum self' checksum' + touchManagedPtr self + freeMem checksum' + return () + +#if ENABLE_OVERLOADING +data MutableTreeSetContentsChecksumMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeSetContentsChecksumMethodInfo a signature where + overloadedMethod _ = mutableTreeSetContentsChecksum + +#endif + +-- method MutableTree::set_metadata_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_set_metadata_checksum" ostree_mutable_tree_set_metadata_checksum :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + CString -> -- checksum : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +mutableTreeSetMetadataChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + -> T.Text + -> m () +mutableTreeSetMetadataChecksum self checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + ostree_mutable_tree_set_metadata_checksum self' checksum' + touchManagedPtr self + freeMem checksum' + return () + +#if ENABLE_OVERLOADING +data MutableTreeSetMetadataChecksumMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeSetMetadataChecksumMethodInfo a signature where + overloadedMethod _ = mutableTreeSetMetadataChecksum + +#endif + +-- method MutableTree::walk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "split_path", argType = TPtrArray (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Split pathname", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Descend from this number of elements in @split_path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_subdir", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Target parent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_mutable_tree_walk" ostree_mutable_tree_walk :: + Ptr MutableTree -> -- self : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (GPtrArray CString) -> -- split_path : TPtrArray (TBasicType TUTF8) + Word32 -> -- start : TBasicType TUInt + Ptr (Ptr MutableTree) -> -- out_subdir : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Traverse /@start@/ number of elements starting from /@splitPath@/; the +child will be returned in /@outSubdir@/. +-} +mutableTreeWalk :: + (B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) => + a + {- ^ /@self@/: Tree -} + -> [T.Text] + {- ^ /@splitPath@/: Split pathname -} + -> Word32 + {- ^ /@start@/: Descend from this number of elements in /@splitPath@/ -} + -> m (MutableTree) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mutableTreeWalk self splitPath start = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + splitPath' <- mapM textToCString splitPath + splitPath'' <- packGPtrArray splitPath' + outSubdir <- allocMem :: IO (Ptr (Ptr MutableTree)) + onException (do + _ <- propagateGError $ ostree_mutable_tree_walk self' splitPath'' start outSubdir + outSubdir' <- peek outSubdir + outSubdir'' <- (wrapObject MutableTree) outSubdir' + touchManagedPtr self + mapPtrArray freeMem splitPath'' + unrefPtrArray splitPath'' + freeMem outSubdir + return outSubdir'' + ) (do + mapPtrArray freeMem splitPath'' + unrefPtrArray splitPath'' + freeMem outSubdir + ) + +#if ENABLE_OVERLOADING +data MutableTreeWalkMethodInfo +instance (signature ~ ([T.Text] -> Word32 -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.MethodInfo MutableTreeWalkMethodInfo a signature where + overloadedMethod _ = mutableTreeWalk + +#endif + + diff --git a/GI/OSTree/Objects/MutableTree.hs-boot b/GI/OSTree/Objects/MutableTree.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/MutableTree.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.MutableTree 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype MutableTree = MutableTree (ManagedPtr MutableTree) +instance GObject MutableTree where +class (GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o +instance (GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o +instance O.HasParentTypes MutableTree +#if ENABLE_OVERLOADING +data MutableTreeCheckErrorMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeEnsureDirMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeEnsureParentDirsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeFillEmptyFromDirtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeGetContentsChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeGetFilesMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeGetMetadataChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeGetSubdirsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeLookupMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeReplaceFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeSetContentsChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeSetMetadataChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data MutableTreeWalkMethodInfo +#endif diff --git a/GI/OSTree/Objects/Repo.hs b/GI/OSTree/Objects/Repo.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Repo.hs @@ -0,0 +1,8588 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.Repo + ( +#if ENABLE_OVERLOADING + RepoListCollectionRefsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoListCommitObjectsStartingWithMethodInfo, +#endif +#if ENABLE_OVERLOADING + RepoListObjectsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoListRefsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoListRefsExtMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoRemoteListCollectionRefsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoRemoteListRefsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoTraverseCommitMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoTraverseReachableRefsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoTraverseNewParentsMethodInfo , +#endif +#if ENABLE_OVERLOADING + RepoTraverseNewReachableMethodInfo , +#endif + +-- * Exported types + Repo(..) , + IsRepo , + toRepo , + noRepo , + + + -- * Methods +-- ** abortTransaction #method:abortTransaction# + +#if ENABLE_OVERLOADING + RepoAbortTransactionMethodInfo , +#endif + repoAbortTransaction , + + +-- ** addGpgSignatureSummary #method:addGpgSignatureSummary# + +#if ENABLE_OVERLOADING + RepoAddGpgSignatureSummaryMethodInfo , +#endif + repoAddGpgSignatureSummary , + + +-- ** appendGpgSignature #method:appendGpgSignature# + +#if ENABLE_OVERLOADING + RepoAppendGpgSignatureMethodInfo , +#endif + repoAppendGpgSignature , + + +-- ** checkoutAt #method:checkoutAt# + +#if ENABLE_OVERLOADING + RepoCheckoutAtMethodInfo , +#endif + repoCheckoutAt , + + +-- ** checkoutGc #method:checkoutGc# + +#if ENABLE_OVERLOADING + RepoCheckoutGcMethodInfo , +#endif + repoCheckoutGc , + + +-- ** checkoutTree #method:checkoutTree# + +#if ENABLE_OVERLOADING + RepoCheckoutTreeMethodInfo , +#endif + repoCheckoutTree , + + +-- ** commitTransaction #method:commitTransaction# + +#if ENABLE_OVERLOADING + RepoCommitTransactionMethodInfo , +#endif + repoCommitTransaction , + + +-- ** copyConfig #method:copyConfig# + +#if ENABLE_OVERLOADING + RepoCopyConfigMethodInfo , +#endif + repoCopyConfig , + + +-- ** create #method:create# + +#if ENABLE_OVERLOADING + RepoCreateMethodInfo , +#endif + repoCreate , + + +-- ** createAt #method:createAt# + + repoCreateAt , + + +-- ** deleteObject #method:deleteObject# + +#if ENABLE_OVERLOADING + RepoDeleteObjectMethodInfo , +#endif + repoDeleteObject , + + +-- ** equal #method:equal# + +#if ENABLE_OVERLOADING + RepoEqualMethodInfo , +#endif + repoEqual , + + +-- ** findRemotesAsync #method:findRemotesAsync# + +#if ENABLE_OVERLOADING + RepoFindRemotesAsyncMethodInfo , +#endif + repoFindRemotesAsync , + + +-- ** findRemotesFinish #method:findRemotesFinish# + +#if ENABLE_OVERLOADING + RepoFindRemotesFinishMethodInfo , +#endif + repoFindRemotesFinish , + + +-- ** fsckObject #method:fsckObject# + +#if ENABLE_OVERLOADING + RepoFsckObjectMethodInfo , +#endif + repoFsckObject , + + +-- ** getBootloader #method:getBootloader# + +#if ENABLE_OVERLOADING + RepoGetBootloaderMethodInfo , +#endif + repoGetBootloader , + + +-- ** getCollectionId #method:getCollectionId# + +#if ENABLE_OVERLOADING + RepoGetCollectionIdMethodInfo , +#endif + repoGetCollectionId , + + +-- ** getConfig #method:getConfig# + +#if ENABLE_OVERLOADING + RepoGetConfigMethodInfo , +#endif + repoGetConfig , + + +-- ** getDefaultRepoFinders #method:getDefaultRepoFinders# + +#if ENABLE_OVERLOADING + RepoGetDefaultRepoFindersMethodInfo , +#endif + repoGetDefaultRepoFinders , + + +-- ** getDfd #method:getDfd# + +#if ENABLE_OVERLOADING + RepoGetDfdMethodInfo , +#endif + repoGetDfd , + + +-- ** getDisableFsync #method:getDisableFsync# + +#if ENABLE_OVERLOADING + RepoGetDisableFsyncMethodInfo , +#endif + repoGetDisableFsync , + + +-- ** getMinFreeSpaceBytes #method:getMinFreeSpaceBytes# + +#if ENABLE_OVERLOADING + RepoGetMinFreeSpaceBytesMethodInfo , +#endif + repoGetMinFreeSpaceBytes , + + +-- ** getMode #method:getMode# + +#if ENABLE_OVERLOADING + RepoGetModeMethodInfo , +#endif + repoGetMode , + + +-- ** getParent #method:getParent# + +#if ENABLE_OVERLOADING + RepoGetParentMethodInfo , +#endif + repoGetParent , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + RepoGetPathMethodInfo , +#endif + repoGetPath , + + +-- ** getRemoteBooleanOption #method:getRemoteBooleanOption# + +#if ENABLE_OVERLOADING + RepoGetRemoteBooleanOptionMethodInfo , +#endif + repoGetRemoteBooleanOption , + + +-- ** getRemoteListOption #method:getRemoteListOption# + +#if ENABLE_OVERLOADING + RepoGetRemoteListOptionMethodInfo , +#endif + repoGetRemoteListOption , + + +-- ** getRemoteOption #method:getRemoteOption# + +#if ENABLE_OVERLOADING + RepoGetRemoteOptionMethodInfo , +#endif + repoGetRemoteOption , + + +-- ** gpgVerifyData #method:gpgVerifyData# + +#if ENABLE_OVERLOADING + RepoGpgVerifyDataMethodInfo , +#endif + repoGpgVerifyData , + + +-- ** hasObject #method:hasObject# + +#if ENABLE_OVERLOADING + RepoHasObjectMethodInfo , +#endif + repoHasObject , + + +-- ** hash #method:hash# + +#if ENABLE_OVERLOADING + RepoHashMethodInfo , +#endif + repoHash , + + +-- ** importObjectFrom #method:importObjectFrom# + +#if ENABLE_OVERLOADING + RepoImportObjectFromMethodInfo , +#endif + repoImportObjectFrom , + + +-- ** importObjectFromWithTrust #method:importObjectFromWithTrust# + +#if ENABLE_OVERLOADING + RepoImportObjectFromWithTrustMethodInfo , +#endif + repoImportObjectFromWithTrust , + + +-- ** isSystem #method:isSystem# + +#if ENABLE_OVERLOADING + RepoIsSystemMethodInfo , +#endif + repoIsSystem , + + +-- ** isWritable #method:isWritable# + +#if ENABLE_OVERLOADING + RepoIsWritableMethodInfo , +#endif + repoIsWritable , + + +-- ** listStaticDeltaNames #method:listStaticDeltaNames# + +#if ENABLE_OVERLOADING + RepoListStaticDeltaNamesMethodInfo , +#endif + repoListStaticDeltaNames , + + +-- ** loadCommit #method:loadCommit# + +#if ENABLE_OVERLOADING + RepoLoadCommitMethodInfo , +#endif + repoLoadCommit , + + +-- ** loadFile #method:loadFile# + +#if ENABLE_OVERLOADING + RepoLoadFileMethodInfo , +#endif + repoLoadFile , + + +-- ** loadObjectStream #method:loadObjectStream# + +#if ENABLE_OVERLOADING + RepoLoadObjectStreamMethodInfo , +#endif + repoLoadObjectStream , + + +-- ** loadVariant #method:loadVariant# + +#if ENABLE_OVERLOADING + RepoLoadVariantMethodInfo , +#endif + repoLoadVariant , + + +-- ** loadVariantIfExists #method:loadVariantIfExists# + +#if ENABLE_OVERLOADING + RepoLoadVariantIfExistsMethodInfo , +#endif + repoLoadVariantIfExists , + + +-- ** markCommitPartial #method:markCommitPartial# + +#if ENABLE_OVERLOADING + RepoMarkCommitPartialMethodInfo , +#endif + repoMarkCommitPartial , + + +-- ** modeFromString #method:modeFromString# + + repoModeFromString , + + +-- ** new #method:new# + + repoNew , + + +-- ** newDefault #method:newDefault# + + repoNewDefault , + + +-- ** newForSysrootPath #method:newForSysrootPath# + + repoNewForSysrootPath , + + +-- ** open #method:open# + +#if ENABLE_OVERLOADING + RepoOpenMethodInfo , +#endif + repoOpen , + + +-- ** openAt #method:openAt# + + repoOpenAt , + + +-- ** prepareTransaction #method:prepareTransaction# + +#if ENABLE_OVERLOADING + RepoPrepareTransactionMethodInfo , +#endif + repoPrepareTransaction , + + +-- ** prune #method:prune# + +#if ENABLE_OVERLOADING + RepoPruneMethodInfo , +#endif + repoPrune , + + +-- ** pruneFromReachable #method:pruneFromReachable# + +#if ENABLE_OVERLOADING + RepoPruneFromReachableMethodInfo , +#endif + repoPruneFromReachable , + + +-- ** pruneStaticDeltas #method:pruneStaticDeltas# + +#if ENABLE_OVERLOADING + RepoPruneStaticDeltasMethodInfo , +#endif + repoPruneStaticDeltas , + + +-- ** pull #method:pull# + +#if ENABLE_OVERLOADING + RepoPullMethodInfo , +#endif + repoPull , + + +-- ** pullDefaultConsoleProgressChanged #method:pullDefaultConsoleProgressChanged# + + repoPullDefaultConsoleProgressChanged , + + +-- ** pullFromRemotesAsync #method:pullFromRemotesAsync# + +#if ENABLE_OVERLOADING + RepoPullFromRemotesAsyncMethodInfo , +#endif + repoPullFromRemotesAsync , + + +-- ** pullFromRemotesFinish #method:pullFromRemotesFinish# + +#if ENABLE_OVERLOADING + RepoPullFromRemotesFinishMethodInfo , +#endif + repoPullFromRemotesFinish , + + +-- ** pullOneDir #method:pullOneDir# + +#if ENABLE_OVERLOADING + RepoPullOneDirMethodInfo , +#endif + repoPullOneDir , + + +-- ** pullWithOptions #method:pullWithOptions# + +#if ENABLE_OVERLOADING + RepoPullWithOptionsMethodInfo , +#endif + repoPullWithOptions , + + +-- ** queryObjectStorageSize #method:queryObjectStorageSize# + +#if ENABLE_OVERLOADING + RepoQueryObjectStorageSizeMethodInfo , +#endif + repoQueryObjectStorageSize , + + +-- ** readCommit #method:readCommit# + +#if ENABLE_OVERLOADING + RepoReadCommitMethodInfo , +#endif + repoReadCommit , + + +-- ** readCommitDetachedMetadata #method:readCommitDetachedMetadata# + +#if ENABLE_OVERLOADING + RepoReadCommitDetachedMetadataMethodInfo, +#endif + repoReadCommitDetachedMetadata , + + +-- ** regenerateSummary #method:regenerateSummary# + +#if ENABLE_OVERLOADING + RepoRegenerateSummaryMethodInfo , +#endif + repoRegenerateSummary , + + +-- ** reloadConfig #method:reloadConfig# + +#if ENABLE_OVERLOADING + RepoReloadConfigMethodInfo , +#endif + repoReloadConfig , + + +-- ** remoteAdd #method:remoteAdd# + +#if ENABLE_OVERLOADING + RepoRemoteAddMethodInfo , +#endif + repoRemoteAdd , + + +-- ** remoteChange #method:remoteChange# + +#if ENABLE_OVERLOADING + RepoRemoteChangeMethodInfo , +#endif + repoRemoteChange , + + +-- ** remoteDelete #method:remoteDelete# + +#if ENABLE_OVERLOADING + RepoRemoteDeleteMethodInfo , +#endif + repoRemoteDelete , + + +-- ** remoteFetchSummary #method:remoteFetchSummary# + +#if ENABLE_OVERLOADING + RepoRemoteFetchSummaryMethodInfo , +#endif + repoRemoteFetchSummary , + + +-- ** remoteFetchSummaryWithOptions #method:remoteFetchSummaryWithOptions# + +#if ENABLE_OVERLOADING + RepoRemoteFetchSummaryWithOptionsMethodInfo, +#endif + repoRemoteFetchSummaryWithOptions , + + +-- ** remoteGetGpgVerify #method:remoteGetGpgVerify# + +#if ENABLE_OVERLOADING + RepoRemoteGetGpgVerifyMethodInfo , +#endif + repoRemoteGetGpgVerify , + + +-- ** remoteGetGpgVerifySummary #method:remoteGetGpgVerifySummary# + +#if ENABLE_OVERLOADING + RepoRemoteGetGpgVerifySummaryMethodInfo , +#endif + repoRemoteGetGpgVerifySummary , + + +-- ** remoteGetUrl #method:remoteGetUrl# + +#if ENABLE_OVERLOADING + RepoRemoteGetUrlMethodInfo , +#endif + repoRemoteGetUrl , + + +-- ** remoteGpgImport #method:remoteGpgImport# + +#if ENABLE_OVERLOADING + RepoRemoteGpgImportMethodInfo , +#endif + repoRemoteGpgImport , + + +-- ** remoteList #method:remoteList# + +#if ENABLE_OVERLOADING + RepoRemoteListMethodInfo , +#endif + repoRemoteList , + + +-- ** resolveCollectionRef #method:resolveCollectionRef# + +#if ENABLE_OVERLOADING + RepoResolveCollectionRefMethodInfo , +#endif + repoResolveCollectionRef , + + +-- ** resolveKeyringForCollection #method:resolveKeyringForCollection# + +#if ENABLE_OVERLOADING + RepoResolveKeyringForCollectionMethodInfo, +#endif + repoResolveKeyringForCollection , + + +-- ** resolveRev #method:resolveRev# + +#if ENABLE_OVERLOADING + RepoResolveRevMethodInfo , +#endif + repoResolveRev , + + +-- ** resolveRevExt #method:resolveRevExt# + +#if ENABLE_OVERLOADING + RepoResolveRevExtMethodInfo , +#endif + repoResolveRevExt , + + +-- ** scanHardlinks #method:scanHardlinks# + +#if ENABLE_OVERLOADING + RepoScanHardlinksMethodInfo , +#endif + repoScanHardlinks , + + +-- ** setAliasRefImmediate #method:setAliasRefImmediate# + +#if ENABLE_OVERLOADING + RepoSetAliasRefImmediateMethodInfo , +#endif + repoSetAliasRefImmediate , + + +-- ** setCacheDir #method:setCacheDir# + +#if ENABLE_OVERLOADING + RepoSetCacheDirMethodInfo , +#endif + repoSetCacheDir , + + +-- ** setCollectionId #method:setCollectionId# + +#if ENABLE_OVERLOADING + RepoSetCollectionIdMethodInfo , +#endif + repoSetCollectionId , + + +-- ** setCollectionRefImmediate #method:setCollectionRefImmediate# + +#if ENABLE_OVERLOADING + RepoSetCollectionRefImmediateMethodInfo , +#endif + repoSetCollectionRefImmediate , + + +-- ** setDisableFsync #method:setDisableFsync# + +#if ENABLE_OVERLOADING + RepoSetDisableFsyncMethodInfo , +#endif + repoSetDisableFsync , + + +-- ** setRefImmediate #method:setRefImmediate# + +#if ENABLE_OVERLOADING + RepoSetRefImmediateMethodInfo , +#endif + repoSetRefImmediate , + + +-- ** signCommit #method:signCommit# + +#if ENABLE_OVERLOADING + RepoSignCommitMethodInfo , +#endif + repoSignCommit , + + +-- ** signDelta #method:signDelta# + +#if ENABLE_OVERLOADING + RepoSignDeltaMethodInfo , +#endif + repoSignDelta , + + +-- ** staticDeltaExecuteOffline #method:staticDeltaExecuteOffline# + +#if ENABLE_OVERLOADING + RepoStaticDeltaExecuteOfflineMethodInfo , +#endif + repoStaticDeltaExecuteOffline , + + +-- ** staticDeltaGenerate #method:staticDeltaGenerate# + +#if ENABLE_OVERLOADING + RepoStaticDeltaGenerateMethodInfo , +#endif + repoStaticDeltaGenerate , + + +-- ** transactionSetCollectionRef #method:transactionSetCollectionRef# + +#if ENABLE_OVERLOADING + RepoTransactionSetCollectionRefMethodInfo, +#endif + repoTransactionSetCollectionRef , + + +-- ** transactionSetRef #method:transactionSetRef# + +#if ENABLE_OVERLOADING + RepoTransactionSetRefMethodInfo , +#endif + repoTransactionSetRef , + + +-- ** transactionSetRefspec #method:transactionSetRefspec# + +#if ENABLE_OVERLOADING + RepoTransactionSetRefspecMethodInfo , +#endif + repoTransactionSetRefspec , + + +-- ** traverseParentsGetCommits #method:traverseParentsGetCommits# + + repoTraverseParentsGetCommits , + + +-- ** verifyCommit #method:verifyCommit# + +#if ENABLE_OVERLOADING + RepoVerifyCommitMethodInfo , +#endif + repoVerifyCommit , + + +-- ** verifyCommitExt #method:verifyCommitExt# + +#if ENABLE_OVERLOADING + RepoVerifyCommitExtMethodInfo , +#endif + repoVerifyCommitExt , + + +-- ** verifyCommitForRemote #method:verifyCommitForRemote# + +#if ENABLE_OVERLOADING + RepoVerifyCommitForRemoteMethodInfo , +#endif + repoVerifyCommitForRemote , + + +-- ** verifySummary #method:verifySummary# + +#if ENABLE_OVERLOADING + RepoVerifySummaryMethodInfo , +#endif + repoVerifySummary , + + +-- ** writeArchiveToMtree #method:writeArchiveToMtree# + +#if ENABLE_OVERLOADING + RepoWriteArchiveToMtreeMethodInfo , +#endif + repoWriteArchiveToMtree , + + +-- ** writeCommit #method:writeCommit# + +#if ENABLE_OVERLOADING + RepoWriteCommitMethodInfo , +#endif + repoWriteCommit , + + +-- ** writeCommitDetachedMetadata #method:writeCommitDetachedMetadata# + +#if ENABLE_OVERLOADING + RepoWriteCommitDetachedMetadataMethodInfo, +#endif + repoWriteCommitDetachedMetadata , + + +-- ** writeCommitWithTime #method:writeCommitWithTime# + +#if ENABLE_OVERLOADING + RepoWriteCommitWithTimeMethodInfo , +#endif + repoWriteCommitWithTime , + + +-- ** writeConfig #method:writeConfig# + +#if ENABLE_OVERLOADING + RepoWriteConfigMethodInfo , +#endif + repoWriteConfig , + + +-- ** writeContent #method:writeContent# + +#if ENABLE_OVERLOADING + RepoWriteContentMethodInfo , +#endif + repoWriteContent , + + +-- ** writeContentAsync #method:writeContentAsync# + +#if ENABLE_OVERLOADING + RepoWriteContentAsyncMethodInfo , +#endif + repoWriteContentAsync , + + +-- ** writeContentFinish #method:writeContentFinish# + +#if ENABLE_OVERLOADING + RepoWriteContentFinishMethodInfo , +#endif + repoWriteContentFinish , + + +-- ** writeContentTrusted #method:writeContentTrusted# + +#if ENABLE_OVERLOADING + RepoWriteContentTrustedMethodInfo , +#endif + repoWriteContentTrusted , + + +-- ** writeDfdToMtree #method:writeDfdToMtree# + +#if ENABLE_OVERLOADING + RepoWriteDfdToMtreeMethodInfo , +#endif + repoWriteDfdToMtree , + + +-- ** writeDirectoryToMtree #method:writeDirectoryToMtree# + +#if ENABLE_OVERLOADING + RepoWriteDirectoryToMtreeMethodInfo , +#endif + repoWriteDirectoryToMtree , + + +-- ** writeMetadata #method:writeMetadata# + +#if ENABLE_OVERLOADING + RepoWriteMetadataMethodInfo , +#endif + repoWriteMetadata , + + +-- ** writeMetadataAsync #method:writeMetadataAsync# + +#if ENABLE_OVERLOADING + RepoWriteMetadataAsyncMethodInfo , +#endif + repoWriteMetadataAsync , + + +-- ** writeMetadataFinish #method:writeMetadataFinish# + +#if ENABLE_OVERLOADING + RepoWriteMetadataFinishMethodInfo , +#endif + repoWriteMetadataFinish , + + +-- ** writeMetadataStreamTrusted #method:writeMetadataStreamTrusted# + +#if ENABLE_OVERLOADING + RepoWriteMetadataStreamTrustedMethodInfo, +#endif + repoWriteMetadataStreamTrusted , + + +-- ** writeMetadataTrusted #method:writeMetadataTrusted# + +#if ENABLE_OVERLOADING + RepoWriteMetadataTrustedMethodInfo , +#endif + repoWriteMetadataTrusted , + + +-- ** writeMtree #method:writeMtree# + +#if ENABLE_OVERLOADING + RepoWriteMtreeMethodInfo , +#endif + repoWriteMtree , + + + + + -- * Properties +-- ** path #attr:path# +{- | Path to repository. Note that if this repository was created +via @ostree_repo_new_at()@, this value will refer to a value in +the Linux kernel\'s @\/proc\/self\/fd@ directory. Generally, you +should avoid using this property at all; you can gain a reference +to the repository\'s directory fd via @ostree_repo_get_dfd()@ and +use file-descriptor relative operations. +-} +#if ENABLE_OVERLOADING + RepoPathPropertyInfo , +#endif + constructRepoPath , + getRepoPath , +#if ENABLE_OVERLOADING + repoPath , +#endif + + +-- ** remotesConfigDir #attr:remotesConfigDir# +{- | Path to directory containing remote definitions. The default is @NULL@. +If a @sysroot-path@ property is defined, this value will default to +@${sysroot_path}\/etc\/ostree\/remotes.d@. + +This value will only be used for system repositories. +-} +#if ENABLE_OVERLOADING + RepoRemotesConfigDirPropertyInfo , +#endif + constructRepoRemotesConfigDir , + getRepoRemotesConfigDir , +#if ENABLE_OVERLOADING + repoRemotesConfigDir , +#endif + + +-- ** sysrootPath #attr:sysrootPath# +{- | A system using libostree for the host has a \"system\" repository; this +property will be set for repositories referenced via +@ostree_sysroot_repo()@ for example. + +You should avoid using this property; if your code is operating +on a system repository, use @OstreeSysroot@ and access the repository +object via @ostree_sysroot_repo()@. +-} +#if ENABLE_OVERLOADING + RepoSysrootPathPropertyInfo , +#endif + constructRepoSysrootPath , + getRepoSysrootPath , +#if ENABLE_OVERLOADING + repoSysrootPath , +#endif + + + + + -- * Signals +-- ** gpgVerifyResult #signal:gpgVerifyResult# + + C_RepoGpgVerifyResultCallback , + RepoGpgVerifyResultCallback , +#if ENABLE_OVERLOADING + RepoGpgVerifyResultSignalInfo , +#endif + afterRepoGpgVerifyResult , + genClosure_RepoGpgVerifyResult , + mk_RepoGpgVerifyResultCallback , + noRepoGpgVerifyResultCallback , + onRepoGpgVerifyResult , + wrap_RepoGpgVerifyResultCallback , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.Bytes as GLib.Bytes +import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo +import qualified GI.Gio.Objects.InputStream as Gio.InputStream +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder +import {-# SOURCE #-} qualified GI.OSTree.Objects.AsyncProgress as OSTree.AsyncProgress +import {-# SOURCE #-} qualified GI.OSTree.Objects.GpgVerifyResult as OSTree.GpgVerifyResult +import {-# SOURCE #-} qualified GI.OSTree.Objects.MutableTree as OSTree.MutableTree +import {-# SOURCE #-} qualified GI.OSTree.Objects.RepoFile as OSTree.RepoFile +import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef +import {-# SOURCE #-} qualified GI.OSTree.Structs.Remote as OSTree.Remote +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCheckoutAtOptions as OSTree.RepoCheckoutAtOptions +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCommitModifier as OSTree.RepoCommitModifier +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoTransactionStats as OSTree.RepoTransactionStats + +-- | Memory-managed wrapper type. +newtype Repo = Repo (ManagedPtr Repo) +foreign import ccall "ostree_repo_get_type" + c_ostree_repo_get_type :: IO GType + +instance GObject Repo where + gobjectType = c_ostree_repo_get_type + + +-- | Type class for types which can be safely cast to `Repo`, for instance with `toRepo`. +class (GObject o, O.IsDescendantOf Repo o) => IsRepo o +instance (GObject o, O.IsDescendantOf Repo o) => IsRepo o + +instance O.HasParentTypes Repo +type instance O.ParentTypes Repo = '[GObject.Object.Object] + +-- | Cast to `Repo`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepo :: (MonadIO m, IsRepo o) => o -> m Repo +toRepo = liftIO . unsafeCastTo Repo + +-- | A convenience alias for `Nothing` :: `Maybe` `Repo`. +noRepo :: Maybe Repo +noRepo = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoMethod "abortTransaction" o = RepoAbortTransactionMethodInfo + ResolveRepoMethod "addGpgSignatureSummary" o = RepoAddGpgSignatureSummaryMethodInfo + ResolveRepoMethod "appendGpgSignature" o = RepoAppendGpgSignatureMethodInfo + ResolveRepoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoMethod "checkoutAt" o = RepoCheckoutAtMethodInfo + ResolveRepoMethod "checkoutGc" o = RepoCheckoutGcMethodInfo + ResolveRepoMethod "checkoutTree" o = RepoCheckoutTreeMethodInfo + ResolveRepoMethod "commitTransaction" o = RepoCommitTransactionMethodInfo + ResolveRepoMethod "copyConfig" o = RepoCopyConfigMethodInfo + ResolveRepoMethod "create" o = RepoCreateMethodInfo + ResolveRepoMethod "deleteObject" o = RepoDeleteObjectMethodInfo + ResolveRepoMethod "equal" o = RepoEqualMethodInfo + ResolveRepoMethod "findRemotesAsync" o = RepoFindRemotesAsyncMethodInfo + ResolveRepoMethod "findRemotesFinish" o = RepoFindRemotesFinishMethodInfo + ResolveRepoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoMethod "fsckObject" o = RepoFsckObjectMethodInfo + ResolveRepoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoMethod "gpgVerifyData" o = RepoGpgVerifyDataMethodInfo + ResolveRepoMethod "hasObject" o = RepoHasObjectMethodInfo + ResolveRepoMethod "hash" o = RepoHashMethodInfo + ResolveRepoMethod "importObjectFrom" o = RepoImportObjectFromMethodInfo + ResolveRepoMethod "importObjectFromWithTrust" o = RepoImportObjectFromWithTrustMethodInfo + ResolveRepoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoMethod "isSystem" o = RepoIsSystemMethodInfo + ResolveRepoMethod "isWritable" o = RepoIsWritableMethodInfo + ResolveRepoMethod "listCollectionRefs" o = RepoListCollectionRefsMethodInfo + ResolveRepoMethod "listCommitObjectsStartingWith" o = RepoListCommitObjectsStartingWithMethodInfo + ResolveRepoMethod "listObjects" o = RepoListObjectsMethodInfo + ResolveRepoMethod "listRefs" o = RepoListRefsMethodInfo + ResolveRepoMethod "listRefsExt" o = RepoListRefsExtMethodInfo + ResolveRepoMethod "listStaticDeltaNames" o = RepoListStaticDeltaNamesMethodInfo + ResolveRepoMethod "loadCommit" o = RepoLoadCommitMethodInfo + ResolveRepoMethod "loadFile" o = RepoLoadFileMethodInfo + ResolveRepoMethod "loadObjectStream" o = RepoLoadObjectStreamMethodInfo + ResolveRepoMethod "loadVariant" o = RepoLoadVariantMethodInfo + ResolveRepoMethod "loadVariantIfExists" o = RepoLoadVariantIfExistsMethodInfo + ResolveRepoMethod "markCommitPartial" o = RepoMarkCommitPartialMethodInfo + ResolveRepoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoMethod "open" o = RepoOpenMethodInfo + ResolveRepoMethod "prepareTransaction" o = RepoPrepareTransactionMethodInfo + ResolveRepoMethod "prune" o = RepoPruneMethodInfo + ResolveRepoMethod "pruneFromReachable" o = RepoPruneFromReachableMethodInfo + ResolveRepoMethod "pruneStaticDeltas" o = RepoPruneStaticDeltasMethodInfo + ResolveRepoMethod "pull" o = RepoPullMethodInfo + ResolveRepoMethod "pullFromRemotesAsync" o = RepoPullFromRemotesAsyncMethodInfo + ResolveRepoMethod "pullFromRemotesFinish" o = RepoPullFromRemotesFinishMethodInfo + ResolveRepoMethod "pullOneDir" o = RepoPullOneDirMethodInfo + ResolveRepoMethod "pullWithOptions" o = RepoPullWithOptionsMethodInfo + ResolveRepoMethod "queryObjectStorageSize" o = RepoQueryObjectStorageSizeMethodInfo + ResolveRepoMethod "readCommit" o = RepoReadCommitMethodInfo + ResolveRepoMethod "readCommitDetachedMetadata" o = RepoReadCommitDetachedMetadataMethodInfo + ResolveRepoMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoMethod "regenerateSummary" o = RepoRegenerateSummaryMethodInfo + ResolveRepoMethod "reloadConfig" o = RepoReloadConfigMethodInfo + ResolveRepoMethod "remoteAdd" o = RepoRemoteAddMethodInfo + ResolveRepoMethod "remoteChange" o = RepoRemoteChangeMethodInfo + ResolveRepoMethod "remoteDelete" o = RepoRemoteDeleteMethodInfo + ResolveRepoMethod "remoteFetchSummary" o = RepoRemoteFetchSummaryMethodInfo + ResolveRepoMethod "remoteFetchSummaryWithOptions" o = RepoRemoteFetchSummaryWithOptionsMethodInfo + ResolveRepoMethod "remoteGetGpgVerify" o = RepoRemoteGetGpgVerifyMethodInfo + ResolveRepoMethod "remoteGetGpgVerifySummary" o = RepoRemoteGetGpgVerifySummaryMethodInfo + ResolveRepoMethod "remoteGetUrl" o = RepoRemoteGetUrlMethodInfo + ResolveRepoMethod "remoteGpgImport" o = RepoRemoteGpgImportMethodInfo + ResolveRepoMethod "remoteList" o = RepoRemoteListMethodInfo + ResolveRepoMethod "remoteListCollectionRefs" o = RepoRemoteListCollectionRefsMethodInfo + ResolveRepoMethod "remoteListRefs" o = RepoRemoteListRefsMethodInfo + ResolveRepoMethod "resolveCollectionRef" o = RepoResolveCollectionRefMethodInfo + ResolveRepoMethod "resolveKeyringForCollection" o = RepoResolveKeyringForCollectionMethodInfo + ResolveRepoMethod "resolveRev" o = RepoResolveRevMethodInfo + ResolveRepoMethod "resolveRevExt" o = RepoResolveRevExtMethodInfo + ResolveRepoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoMethod "scanHardlinks" o = RepoScanHardlinksMethodInfo + ResolveRepoMethod "signCommit" o = RepoSignCommitMethodInfo + ResolveRepoMethod "signDelta" o = RepoSignDeltaMethodInfo + ResolveRepoMethod "staticDeltaExecuteOffline" o = RepoStaticDeltaExecuteOfflineMethodInfo + ResolveRepoMethod "staticDeltaGenerate" o = RepoStaticDeltaGenerateMethodInfo + ResolveRepoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoMethod "transactionSetCollectionRef" o = RepoTransactionSetCollectionRefMethodInfo + ResolveRepoMethod "transactionSetRef" o = RepoTransactionSetRefMethodInfo + ResolveRepoMethod "transactionSetRefspec" o = RepoTransactionSetRefspecMethodInfo + ResolveRepoMethod "traverseCommit" o = RepoTraverseCommitMethodInfo + ResolveRepoMethod "traverseReachableRefs" o = RepoTraverseReachableRefsMethodInfo + ResolveRepoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoMethod "verifyCommit" o = RepoVerifyCommitMethodInfo + ResolveRepoMethod "verifyCommitExt" o = RepoVerifyCommitExtMethodInfo + ResolveRepoMethod "verifyCommitForRemote" o = RepoVerifyCommitForRemoteMethodInfo + ResolveRepoMethod "verifySummary" o = RepoVerifySummaryMethodInfo + ResolveRepoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoMethod "writeArchiveToMtree" o = RepoWriteArchiveToMtreeMethodInfo + ResolveRepoMethod "writeCommit" o = RepoWriteCommitMethodInfo + ResolveRepoMethod "writeCommitDetachedMetadata" o = RepoWriteCommitDetachedMetadataMethodInfo + ResolveRepoMethod "writeCommitWithTime" o = RepoWriteCommitWithTimeMethodInfo + ResolveRepoMethod "writeConfig" o = RepoWriteConfigMethodInfo + ResolveRepoMethod "writeContent" o = RepoWriteContentMethodInfo + ResolveRepoMethod "writeContentAsync" o = RepoWriteContentAsyncMethodInfo + ResolveRepoMethod "writeContentFinish" o = RepoWriteContentFinishMethodInfo + ResolveRepoMethod "writeContentTrusted" o = RepoWriteContentTrustedMethodInfo + ResolveRepoMethod "writeDfdToMtree" o = RepoWriteDfdToMtreeMethodInfo + ResolveRepoMethod "writeDirectoryToMtree" o = RepoWriteDirectoryToMtreeMethodInfo + ResolveRepoMethod "writeMetadata" o = RepoWriteMetadataMethodInfo + ResolveRepoMethod "writeMetadataAsync" o = RepoWriteMetadataAsyncMethodInfo + ResolveRepoMethod "writeMetadataFinish" o = RepoWriteMetadataFinishMethodInfo + ResolveRepoMethod "writeMetadataStreamTrusted" o = RepoWriteMetadataStreamTrustedMethodInfo + ResolveRepoMethod "writeMetadataTrusted" o = RepoWriteMetadataTrustedMethodInfo + ResolveRepoMethod "writeMtree" o = RepoWriteMtreeMethodInfo + ResolveRepoMethod "getBootloader" o = RepoGetBootloaderMethodInfo + ResolveRepoMethod "getCollectionId" o = RepoGetCollectionIdMethodInfo + ResolveRepoMethod "getConfig" o = RepoGetConfigMethodInfo + ResolveRepoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoMethod "getDefaultRepoFinders" o = RepoGetDefaultRepoFindersMethodInfo + ResolveRepoMethod "getDfd" o = RepoGetDfdMethodInfo + ResolveRepoMethod "getDisableFsync" o = RepoGetDisableFsyncMethodInfo + ResolveRepoMethod "getMinFreeSpaceBytes" o = RepoGetMinFreeSpaceBytesMethodInfo + ResolveRepoMethod "getMode" o = RepoGetModeMethodInfo + ResolveRepoMethod "getParent" o = RepoGetParentMethodInfo + ResolveRepoMethod "getPath" o = RepoGetPathMethodInfo + ResolveRepoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoMethod "getRemoteBooleanOption" o = RepoGetRemoteBooleanOptionMethodInfo + ResolveRepoMethod "getRemoteListOption" o = RepoGetRemoteListOptionMethodInfo + ResolveRepoMethod "getRemoteOption" o = RepoGetRemoteOptionMethodInfo + ResolveRepoMethod "setAliasRefImmediate" o = RepoSetAliasRefImmediateMethodInfo + ResolveRepoMethod "setCacheDir" o = RepoSetCacheDirMethodInfo + ResolveRepoMethod "setCollectionId" o = RepoSetCollectionIdMethodInfo + ResolveRepoMethod "setCollectionRefImmediate" o = RepoSetCollectionRefImmediateMethodInfo + ResolveRepoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoMethod "setDisableFsync" o = RepoSetDisableFsyncMethodInfo + ResolveRepoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoMethod "setRefImmediate" o = RepoSetRefImmediateMethodInfo + ResolveRepoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoMethod t Repo, O.MethodInfo info Repo p) => OL.IsLabel t (Repo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- signal Repo::gpg-verify-result +{- | +Emitted during a pull operation upon GPG verification (if enabled). +Applications can connect to this signal to output the verification +results if desired. + +The signal will be emitted from whichever 'GI.GLib.Structs.MainContext.MainContext' is the +thread-default at the point when 'GI.OSTree.Objects.Repo.repoPullWithOptions' +is called. +-} +type RepoGpgVerifyResultCallback = + T.Text + {- ^ /@checksum@/: checksum of the signed object -} + -> OSTree.GpgVerifyResult.GpgVerifyResult + {- ^ /@result@/: an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoGpgVerifyResultCallback`@. +noRepoGpgVerifyResultCallback :: Maybe RepoGpgVerifyResultCallback +noRepoGpgVerifyResultCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_RepoGpgVerifyResultCallback = + Ptr () -> -- object + CString -> + Ptr OSTree.GpgVerifyResult.GpgVerifyResult -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_RepoGpgVerifyResultCallback`. +foreign import ccall "wrapper" + mk_RepoGpgVerifyResultCallback :: C_RepoGpgVerifyResultCallback -> IO (FunPtr C_RepoGpgVerifyResultCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_RepoGpgVerifyResult :: MonadIO m => RepoGpgVerifyResultCallback -> m (GClosure C_RepoGpgVerifyResultCallback) +genClosure_RepoGpgVerifyResult cb = liftIO $ do + let cb' = wrap_RepoGpgVerifyResultCallback cb + mk_RepoGpgVerifyResultCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `RepoGpgVerifyResultCallback` into a `C_RepoGpgVerifyResultCallback`. +wrap_RepoGpgVerifyResultCallback :: + RepoGpgVerifyResultCallback -> + C_RepoGpgVerifyResultCallback +wrap_RepoGpgVerifyResultCallback _cb _ checksum result_ _ = do + checksum' <- cstringToText checksum + result_' <- (newObject OSTree.GpgVerifyResult.GpgVerifyResult) result_ + _cb checksum' result_' + + +{- | +Connect a signal handler for the “@gpg-verify-result@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' repo #gpgVerifyResult callback +@ +-} +onRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> RepoGpgVerifyResultCallback -> m SignalHandlerId +onRepoGpgVerifyResult obj cb = liftIO $ do + let cb' = wrap_RepoGpgVerifyResultCallback cb + cb'' <- mk_RepoGpgVerifyResultCallback cb' + connectSignalFunPtr obj "gpg-verify-result" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@gpg-verify-result@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' repo #gpgVerifyResult callback +@ +-} +afterRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> RepoGpgVerifyResultCallback -> m SignalHandlerId +afterRepoGpgVerifyResult obj cb = liftIO $ do + let cb' = wrap_RepoGpgVerifyResultCallback cb + cb'' <- mk_RepoGpgVerifyResultCallback cb' + connectSignalFunPtr obj "gpg-verify-result" cb'' SignalConnectAfter + + +-- VVV Prop "path" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repo #path +@ +-} +getRepoPath :: (MonadIO m, IsRepo o) => o -> m Gio.File.File +getRepoPath obj = liftIO $ checkUnexpectedNothing "getRepoPath" $ B.Properties.getObjectPropertyObject obj "path" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepoPath :: (IsRepo o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructRepoPath val = B.Properties.constructObjectPropertyObject "path" (Just val) + +#if ENABLE_OVERLOADING +data RepoPathPropertyInfo +instance AttrInfo RepoPathPropertyInfo where + type AttrAllowedOps RepoPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoPathPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint RepoPathPropertyInfo = IsRepo + type AttrGetType RepoPathPropertyInfo = Gio.File.File + type AttrLabel RepoPathPropertyInfo = "path" + type AttrOrigin RepoPathPropertyInfo = Repo + attrGet _ = getRepoPath + attrSet _ = undefined + attrConstruct _ = constructRepoPath + attrClear _ = undefined +#endif + +-- VVV Prop "remotes-config-dir" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@remotes-config-dir@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repo #remotesConfigDir +@ +-} +getRepoRemotesConfigDir :: (MonadIO m, IsRepo o) => o -> m (Maybe T.Text) +getRepoRemotesConfigDir obj = liftIO $ B.Properties.getObjectPropertyString obj "remotes-config-dir" + +{- | +Construct a `GValueConstruct` with valid value for the “@remotes-config-dir@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepoRemotesConfigDir :: (IsRepo o) => T.Text -> IO (GValueConstruct o) +constructRepoRemotesConfigDir val = B.Properties.constructObjectPropertyString "remotes-config-dir" (Just val) + +#if ENABLE_OVERLOADING +data RepoRemotesConfigDirPropertyInfo +instance AttrInfo RepoRemotesConfigDirPropertyInfo where + type AttrAllowedOps RepoRemotesConfigDirPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo = IsRepo + type AttrGetType RepoRemotesConfigDirPropertyInfo = (Maybe T.Text) + type AttrLabel RepoRemotesConfigDirPropertyInfo = "remotes-config-dir" + type AttrOrigin RepoRemotesConfigDirPropertyInfo = Repo + attrGet _ = getRepoRemotesConfigDir + attrSet _ = undefined + attrConstruct _ = constructRepoRemotesConfigDir + attrClear _ = undefined +#endif + +-- VVV Prop "sysroot-path" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@sysroot-path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repo #sysrootPath +@ +-} +getRepoSysrootPath :: (MonadIO m, IsRepo o) => o -> m (Maybe Gio.File.File) +getRepoSysrootPath obj = liftIO $ B.Properties.getObjectPropertyObject obj "sysroot-path" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@sysroot-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepoSysrootPath :: (IsRepo o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructRepoSysrootPath val = B.Properties.constructObjectPropertyObject "sysroot-path" (Just val) + +#if ENABLE_OVERLOADING +data RepoSysrootPathPropertyInfo +instance AttrInfo RepoSysrootPathPropertyInfo where + type AttrAllowedOps RepoSysrootPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoSysrootPathPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint RepoSysrootPathPropertyInfo = IsRepo + type AttrGetType RepoSysrootPathPropertyInfo = (Maybe Gio.File.File) + type AttrLabel RepoSysrootPathPropertyInfo = "sysroot-path" + type AttrOrigin RepoSysrootPathPropertyInfo = Repo + attrGet _ = getRepoSysrootPath + attrSet _ = undefined + attrConstruct _ = constructRepoSysrootPath + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Repo +type instance O.AttributeList Repo = RepoAttributeList +type RepoAttributeList = ('[ '("path", RepoPathPropertyInfo), '("remotesConfigDir", RepoRemotesConfigDirPropertyInfo), '("sysrootPath", RepoSysrootPathPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +repoPath :: AttrLabelProxy "path" +repoPath = AttrLabelProxy + +repoRemotesConfigDir :: AttrLabelProxy "remotesConfigDir" +repoRemotesConfigDir = AttrLabelProxy + +repoSysrootPath :: AttrLabelProxy "sysrootPath" +repoSysrootPath = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data RepoGpgVerifyResultSignalInfo +instance SignalInfo RepoGpgVerifyResultSignalInfo where + type HaskellCallbackType RepoGpgVerifyResultSignalInfo = RepoGpgVerifyResultCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_RepoGpgVerifyResultCallback cb + cb'' <- mk_RepoGpgVerifyResultCallback cb' + connectSignalFunPtr obj "gpg-verify-result" cb'' connectMode + +type instance O.SignalList Repo = RepoSignalList +type RepoSignalList = ('[ '("gpgVerifyResult", RepoGpgVerifyResultSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Repo::new +-- method type : Constructor +-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to a repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_new" ostree_repo_new :: + Ptr Gio.File.File -> -- path : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr Repo) + +{- | +/No description available in the introspection data./ +-} +repoNew :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@path@/: Path to a repository -} + -> m Repo + {- ^ __Returns:__ An accessor object for an OSTree repository located at /@path@/ -} +repoNew path = liftIO $ do + path' <- unsafeManagedPtrCastPtr path + result <- ostree_repo_new path' + checkUnexpectedReturnNULL "repoNew" result + result' <- (wrapObject Repo) result + touchManagedPtr path + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::new_default +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_new_default" ostree_repo_new_default :: + IO (Ptr Repo) + +{- | +If the current working directory appears to be an OSTree +repository, create a new 'GI.OSTree.Objects.Repo.Repo' object for accessing it. +Otherwise use the path in the OSTREE_REPO environment variable +(if defined) or else the default system repository located at +\/ostree\/repo. +-} +repoNewDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m Repo + {- ^ __Returns:__ An accessor object for an OSTree repository located at \/ostree\/repo -} +repoNewDefault = liftIO $ do + result <- ostree_repo_new_default + checkUnexpectedReturnNULL "repoNewDefault" result + result' <- (wrapObject Repo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::new_for_sysroot_path +-- method type : Constructor +-- Args : [Arg {argCName = "repo_path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to a repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sysroot_path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to the system root", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_new_for_sysroot_path" ostree_repo_new_for_sysroot_path :: + Ptr Gio.File.File -> -- repo_path : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- sysroot_path : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr Repo) + +{- | +Creates a new 'GI.OSTree.Objects.Repo.Repo' instance, taking the system root path explicitly +instead of assuming \"\/\". +-} +repoNewForSysrootPath :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b) => + a + {- ^ /@repoPath@/: Path to a repository -} + -> b + {- ^ /@sysrootPath@/: Path to the system root -} + -> m Repo + {- ^ __Returns:__ An accessor object for the OSTree repository located at /@repoPath@/. -} +repoNewForSysrootPath repoPath sysrootPath = liftIO $ do + repoPath' <- unsafeManagedPtrCastPtr repoPath + sysrootPath' <- unsafeManagedPtrCastPtr sysrootPath + result <- ostree_repo_new_for_sysroot_path repoPath' sysrootPath' + checkUnexpectedReturnNULL "repoNewForSysrootPath" result + result' <- (wrapObject Repo) result + touchManagedPtr repoPath + touchManagedPtr sysrootPath + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::abort_transaction +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_abort_transaction" ostree_repo_abort_transaction :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Abort the active transaction; any staged objects and ref changes will be +discarded. You *must* invoke this if you have chosen not to invoke +'GI.OSTree.Objects.Repo.repoCommitTransaction'. Calling this function when not in a +transaction will do nothing and return successfully. +-} +repoAbortTransaction :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoAbortTransaction self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_abort_transaction self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoAbortTransactionMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoAbortTransactionMethodInfo a signature where + overloadedMethod _ = repoAbortTransaction + +#endif + +-- method Repo::add_gpg_signature_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key_id", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "NULL-terminated array of GPG keys.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "homedir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GPG home directory, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_add_gpg_signature_summary" ostree_repo_add_gpg_signature_summary :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr CString -> -- key_id : TCArray True (-1) (-1) (TBasicType TUTF8) + CString -> -- homedir : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a GPG signature to a summary file. +-} +repoAddGpgSignatureSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> [T.Text] + {- ^ /@keyId@/: NULL-terminated array of GPG keys. -} + -> Maybe (T.Text) + {- ^ /@homedir@/: GPG home directory, or 'Nothing' -} + -> Maybe (b) + {- ^ /@cancellable@/: A 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoAddGpgSignatureSummary self keyId homedir cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + keyId' <- packZeroTerminatedUTF8CArray keyId + maybeHomedir <- case homedir of + Nothing -> return nullPtr + Just jHomedir -> do + jHomedir' <- textToCString jHomedir + return jHomedir' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_add_gpg_signature_summary self' keyId' maybeHomedir maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + mapZeroTerminatedCArray freeMem keyId' + freeMem keyId' + freeMem maybeHomedir + return () + ) (do + mapZeroTerminatedCArray freeMem keyId' + freeMem keyId' + freeMem maybeHomedir + ) + +#if ENABLE_OVERLOADING +data RepoAddGpgSignatureSummaryMethodInfo +instance (signature ~ ([T.Text] -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoAddGpgSignatureSummaryMethodInfo a signature where + overloadedMethod _ = repoAddGpgSignatureSummary + +#endif + +-- method Repo::append_gpg_signature +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "SHA256 of given commit to sign", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signature data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_append_gpg_signature" ostree_repo_append_gpg_signature :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit_checksum : TBasicType TUTF8 + Ptr GLib.Bytes.Bytes -> -- signature_bytes : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Append a GPG signature to a commit. +-} +repoAppendGpgSignature :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@commitChecksum@/: SHA256 of given commit to sign -} + -> GLib.Bytes.Bytes + {- ^ /@signatureBytes@/: Signature data -} + -> Maybe (b) + {- ^ /@cancellable@/: A 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoAppendGpgSignature self commitChecksum signatureBytes cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + commitChecksum' <- textToCString commitChecksum + signatureBytes' <- unsafeManagedPtrGetPtr signatureBytes + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_append_gpg_signature self' commitChecksum' signatureBytes' maybeCancellable + touchManagedPtr self + touchManagedPtr signatureBytes + whenJust cancellable touchManagedPtr + freeMem commitChecksum' + return () + ) (do + freeMem commitChecksum' + ) + +#if ENABLE_OVERLOADING +data RepoAppendGpgSignatureMethodInfo +instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoAppendGpgSignatureMethodInfo a signature where + overloadedMethod _ = repoAppendGpgSignature + +#endif + +-- method Repo::checkout_at +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "OSTree", name = "RepoCheckoutAtOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destination_dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory FD for destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destination_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory for destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum for commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_checkout_at" ostree_repo_checkout_at :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutAtOptions"}) + Int32 -> -- destination_dfd : TBasicType TInt + CString -> -- destination_path : TBasicType TUTF8 + CString -> -- commit : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Similar to 'GI.OSTree.Objects.Repo.repoCheckoutTree', but uses directory-relative +paths for the destination, uses a new @OstreeRepoCheckoutAtOptions@, +and takes a commit checksum and optional subpath pair, rather than +requiring use of @GFile@ APIs for the caller. + +It also replaces 'GI.OSTree.Objects.Repo.repoCheckoutAt' which was not safe to +use with GObject introspection. + +Note in addition that unlike 'GI.OSTree.Objects.Repo.repoCheckoutTree', the +default is not to use the repository-internal uncompressed objects +cache. +-} +repoCheckoutAt :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> Maybe (OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions) + {- ^ /@options@/: Options -} + -> Int32 + {- ^ /@destinationDfd@/: Directory FD for destination -} + -> T.Text + {- ^ /@destinationPath@/: Directory for destination -} + -> T.Text + {- ^ /@commit@/: Checksum for commit -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCheckoutAt self options destinationDfd destinationPath commit cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + destinationPath' <- textToCString destinationPath + commit' <- textToCString commit + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_checkout_at self' maybeOptions destinationDfd destinationPath' commit' maybeCancellable + touchManagedPtr self + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem destinationPath' + freeMem commit' + return () + ) (do + freeMem destinationPath' + freeMem commit' + ) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtMethodInfo +instance (signature ~ (Maybe (OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions) -> Int32 -> T.Text -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoCheckoutAtMethodInfo a signature where + overloadedMethod _ = repoCheckoutAt + +#endif + +-- method Repo::checkout_gc +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_checkout_gc" ostree_repo_checkout_gc :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Call this after finishing a succession of checkout operations; it +will delete any currently-unused uncompressed objects from the +cache. +-} +repoCheckoutGc :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCheckoutGc self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_checkout_gc self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCheckoutGcMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoCheckoutGcMethodInfo a signature where + overloadedMethod _ = repoCheckoutGc + +#endif + +-- method Repo::checkout_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "OSTree", name = "RepoCheckoutMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling all files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overwrite_mode", argType = TInterface (Name {namespace = "OSTree", name = "RepoCheckoutOverwriteMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not to overwrite files", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destination", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Place tree here", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_checkout_tree" ostree_repo_checkout_tree :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- mode : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutMode"}) + CUInt -> -- overwrite_mode : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutOverwriteMode"}) + Ptr Gio.File.File -> -- destination : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr OSTree.RepoFile.RepoFile -> -- source : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Ptr Gio.FileInfo.FileInfo -> -- source_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check out /@source@/ into /@destination@/, which must live on the +physical filesystem. /@source@/ may be any subdirectory of a given +commit. The /@mode@/ and /@overwriteMode@/ allow control over how the +files are checked out. +-} +repoCheckoutTree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.RepoFile.IsRepoFile c, Gio.FileInfo.IsFileInfo d, Gio.Cancellable.IsCancellable e) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.RepoCheckoutMode + {- ^ /@mode@/: Options controlling all files -} + -> OSTree.Enums.RepoCheckoutOverwriteMode + {- ^ /@overwriteMode@/: Whether or not to overwrite files -} + -> b + {- ^ /@destination@/: Place tree here -} + -> c + {- ^ /@source@/: Source tree -} + -> d + {- ^ /@sourceInfo@/: Source info -} + -> Maybe (e) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCheckoutTree self mode overwriteMode destination source sourceInfo cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let mode' = (fromIntegral . fromEnum) mode + let overwriteMode' = (fromIntegral . fromEnum) overwriteMode + destination' <- unsafeManagedPtrCastPtr destination + source' <- unsafeManagedPtrCastPtr source + sourceInfo' <- unsafeManagedPtrCastPtr sourceInfo + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_checkout_tree self' mode' overwriteMode' destination' source' sourceInfo' maybeCancellable + touchManagedPtr self + touchManagedPtr destination + touchManagedPtr source + touchManagedPtr sourceInfo + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCheckoutTreeMethodInfo +instance (signature ~ (OSTree.Enums.RepoCheckoutMode -> OSTree.Enums.RepoCheckoutOverwriteMode -> b -> c -> d -> Maybe (e) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.RepoFile.IsRepoFile c, Gio.FileInfo.IsFileInfo d, Gio.Cancellable.IsCancellable e) => O.MethodInfo RepoCheckoutTreeMethodInfo a signature where + overloadedMethod _ = repoCheckoutTree + +#endif + +-- method Repo::commit_transaction +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_stats", argType = TInterface (Name {namespace = "OSTree", name = "RepoTransactionStats"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A set of statistics of things\nthat happened during this transaction.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_commit_transaction" ostree_repo_commit_transaction :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.RepoTransactionStats.RepoTransactionStats -> -- out_stats : TInterface (Name {namespace = "OSTree", name = "RepoTransactionStats"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Complete the transaction. Any refs set with +'GI.OSTree.Objects.Repo.repoTransactionSetRef' or +'GI.OSTree.Objects.Repo.repoTransactionSetRefspec' will be written out. + +Note that if multiple threads are performing writes, all such threads must +have terminated before this function is invoked. + +Locking: Releases @shared@ lock acquired by @ostree_repo_prepare_transaction()@ +Multithreading: This function is *not* MT safe; only one transaction can be +active at a time. +-} +repoCommitTransaction :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (OSTree.RepoTransactionStats.RepoTransactionStats) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCommitTransaction self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outStats <- callocBoxedBytes 56 :: IO (Ptr OSTree.RepoTransactionStats.RepoTransactionStats) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_commit_transaction self' outStats maybeCancellable + outStats' <- (wrapBoxed OSTree.RepoTransactionStats.RepoTransactionStats) outStats + touchManagedPtr self + whenJust cancellable touchManagedPtr + return outStats' + ) (do + freeMem outStats + ) + +#if ENABLE_OVERLOADING +data RepoCommitTransactionMethodInfo +instance (signature ~ (Maybe (b) -> m (OSTree.RepoTransactionStats.RepoTransactionStats)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoCommitTransactionMethodInfo a signature where + overloadedMethod _ = repoCommitTransaction + +#endif + +-- method Repo::copy_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_copy_config" ostree_repo_copy_config :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +repoCopyConfig :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ A newly-allocated copy of the repository config -} +repoCopyConfig self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_copy_config self' + checkUnexpectedReturnNULL "repoCopyConfig" result + result' <- (wrapBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoCopyConfigMethodInfo +instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsRepo a) => O.MethodInfo RepoCopyConfigMethodInfo a signature where + overloadedMethod _ = repoCopyConfig + +#endif + +-- method Repo::create +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "OSTree", name = "RepoMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The mode to store the repository in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_create" ostree_repo_create :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Create the underlying structure on disk for the repository, and call +'GI.OSTree.Objects.Repo.repoOpen' on the result, preparing it for use. + +Since version 2016.8, this function will succeed on an existing +repository, and finish creating any necessary files in a partially +created repository. However, this function cannot change the mode +of an existing repository, and will silently ignore an attempt to +do so. + +Since 2017.9, \"existing repository\" is defined by the existence of an +@objects@ subdirectory. + +This function predates 'GI.OSTree.Objects.Repo.repoCreateAt'. It is an error to call +this function on a repository initialized via 'GI.OSTree.Objects.Repo.repoOpenAt'. +-} +repoCreate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> OSTree.Enums.RepoMode + {- ^ /@mode@/: The mode to store the repository in -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCreate self mode cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let mode' = (fromIntegral . fromEnum) mode + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_create self' mode' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCreateMethodInfo +instance (signature ~ (OSTree.Enums.RepoMode -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoCreateMethodInfo a signature where + overloadedMethod _ = repoCreate + +#endif + +-- method Repo::delete_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_delete_object" ostree_repo_delete_object :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- sha256 : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Remove the object of type /@objtype@/ with checksum /@sha256@/ +from the repository. An error of type 'GI.Gio.Enums.IOErrorEnumNotFound' +is thrown if the object does not exist. +-} +repoDeleteObject :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@sha256@/: Checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoDeleteObject self objtype sha256 cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + sha256' <- textToCString sha256 + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_delete_object self' objtype' sha256' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem sha256' + return () + ) (do + freeMem sha256' + ) + +#if ENABLE_OVERLOADING +data RepoDeleteObjectMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoDeleteObjectMethodInfo a signature where + overloadedMethod _ = repoDeleteObject + +#endif + +-- method Repo::equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_equal" ostree_repo_equal :: + Ptr Repo -> -- a : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Repo -> -- b : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CInt + +{- | +Check whether two opened repositories are the same on disk: if their root +directories are the same inode. If /@a@/ or /@b@/ are not open yet (due to +'GI.OSTree.Objects.Repo.repoOpen' not being called on them yet), 'False' will be returned. + +/Since: 2017.12/ +-} +repoEqual :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b) => + a + {- ^ /@a@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> b + {- ^ /@b@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@a@/ and /@b@/ are the same repository on disk, 'False' otherwise -} +repoEqual a b = liftIO $ do + a' <- unsafeManagedPtrCastPtr a + b' <- unsafeManagedPtrCastPtr b + result <- ostree_repo_equal a' b' + let result' = (/= 0) result + touchManagedPtr a + touchManagedPtr b + return result' + +#if ENABLE_OVERLOADING +data RepoEqualMethodInfo +instance (signature ~ (b -> m Bool), MonadIO m, IsRepo a, IsRepo b) => O.MethodInfo RepoEqualMethodInfo a signature where + overloadedMethod _ = repoEqual + +#endif + +-- method Repo::find_remotes_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refs", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "non-empty array of collection\8211ref pairs to find remotes for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a GVariant `a{sv}` with an extensible set of flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "finders", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "non-empty array of\n #OstreeRepoFinder instances to use, or %NULL to use the system defaults", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress to update with the operation\8217s\n progress, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "asynchronous completion callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_find_remotes_async" ostree_repo_find_remotes_async :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) + Ptr GVariant -> -- options : TVariant + Ptr (Ptr OSTree.RepoFinder.RepoFinder) -> -- finders : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"})) + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Find reachable remote URIs which claim to provide any of the given named +/@refs@/. This will search for configured remotes ('GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig'), +mounted volumes ('GI.OSTree.Objects.RepoFinderMount.RepoFinderMount') and (if enabled at compile time) +local network peers ('GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi'). In order to use a custom +configuration of 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' instances, call +'GI.OSTree.Functions.repoFinderResolveAllAsync' on them individually. + +Any remote which is found and which claims to support any of the given /@refs@/ +will be returned in the results. It is possible that a remote claims to +support a given ref, but turns out not to — it is not possible to verify this +until 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' is called. + +The returned results will be sorted with the most useful first — this is +typically the remote which claims to provide the most of /@refs@/, at the lowest +latency. + +Each result contains a list of the subset of /@refs@/ it claims to provide. It +is possible for a non-empty list of results to be returned, but for some of +/@refs@/ to not be listed in any of the results. Callers must check for this. + +Pass the results to 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' to pull the given /@refs@/ +from those remotes. + +The following /@options@/ are currently defined: + + * @override-commit-ids@ (@as@): Array of specific commit IDs to fetch. The nth + commit ID applies to the nth ref, so this must be the same length as /@refs@/, if + provided. + * @n-network-retries@ (@u@): Number of times to retry each download on + receiving a transient network error, such as a socket timeout; default is + 5, 0 means return errors without retrying. Since: 2018.6 + +/@finders@/ must be a non-empty 'Nothing'-terminated array of the 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' +instances to use, or 'Nothing' to use the system default set of finders, which +will typically be all available finders using their default options (but +this is not guaranteed). + +GPG verification of commits will be used unconditionally. + +This will use the thread-default 'GI.GLib.Structs.MainContext.MainContext', but will not iterate it. + +/Since: 2018.6/ +-} +repoFindRemotesAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> [OSTree.CollectionRef.CollectionRef] + {- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for -} + -> Maybe (GVariant) + {- ^ /@options@/: a GVariant @a{sv}@ with an extensible set of flags -} + -> [OSTree.RepoFinder.RepoFinder] + {- ^ /@finders@/: non-empty array of + 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' instances to use, or 'Nothing' to use the system defaults -} + -> Maybe (b) + {- ^ /@progress@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' to update with the operation’s + progress, or 'Nothing' -} + -> Maybe (c) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: asynchronous completion callback -} + -> m () +repoFindRemotesAsync self refs options finders progress cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refs' <- mapM unsafeManagedPtrGetPtr refs + refs'' <- packZeroTerminatedPtrArray refs' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + finders' <- mapM unsafeManagedPtrCastPtr finders + finders'' <- packZeroTerminatedPtrArray finders' + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_find_remotes_async self' refs'' maybeOptions finders'' maybeProgress maybeCancellable maybeCallback userData + touchManagedPtr self + mapM_ touchManagedPtr refs + whenJust options touchManagedPtr + mapM_ touchManagedPtr finders + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem refs'' + freeMem finders'' + return () + +#if ENABLE_OVERLOADING +data RepoFindRemotesAsyncMethodInfo +instance (signature ~ ([OSTree.CollectionRef.CollectionRef] -> Maybe (GVariant) -> [OSTree.RepoFinder.RepoFinder] -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoFindRemotesAsyncMethodInfo a signature where + overloadedMethod _ = repoFindRemotesAsync + +#endif + +-- method Repo::find_remotes_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the asynchronous result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_find_remotes_finish" ostree_repo_find_remotes_finish :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (Ptr OSTree.RepoFinderResult.RepoFinderResult)) + +{- | +Finish an asynchronous pull operation started with +'GI.OSTree.Objects.Repo.repoFindRemotesAsync'. + +/Since: 2018.6/ +-} +repoFindRemotesFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> b + {- ^ /@result@/: the asynchronous result -} + -> m [OSTree.RepoFinderResult.RepoFinderResult] + {- ^ __Returns:__ a potentially empty array + of @/OstreeRepoFinderResults/@, followed by a 'Nothing' terminator element; or + 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFindRemotesFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ ostree_repo_find_remotes_finish self' result_' + checkUnexpectedReturnNULL "repoFindRemotesFinish" result + result' <- unpackZeroTerminatedPtrArray result + result'' <- mapM (wrapBoxed OSTree.RepoFinderResult.RepoFinderResult) result' + freeMem result + touchManagedPtr self + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoFindRemotesFinishMethodInfo +instance (signature ~ (b -> m [OSTree.RepoFinderResult.RepoFinderResult]), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RepoFindRemotesFinishMethodInfo a signature where + overloadedMethod _ = repoFindRemotesFinish + +#endif + +-- method Repo::fsck_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_fsck_object" ostree_repo_fsck_object :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- sha256 : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Verify consistency of the object; this performs checks only relevant to the +immediate object itself, such as checksumming. This API call will not itself +traverse metadata objects for example. + +/Since: 2017.15/ +-} +repoFsckObject :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@sha256@/: Checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFsckObject self objtype sha256 cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + sha256' <- textToCString sha256 + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_fsck_object self' objtype' sha256' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem sha256' + return () + ) (do + freeMem sha256' + ) + +#if ENABLE_OVERLOADING +data RepoFsckObjectMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoFsckObjectMethodInfo a signature where + overloadedMethod _ = repoFsckObject + +#endif + +-- method Repo::get_bootloader +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_bootloader" ostree_repo_get_bootloader :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CString + +{- | +Get the bootloader configured. See the documentation for the +\"sysroot.bootloader\" config key. + +/Since: 2019.2/ +-} +repoGetBootloader :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> m T.Text + {- ^ __Returns:__ bootloader configuration for the sysroot -} +repoGetBootloader self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_bootloader self' + checkUnexpectedReturnNULL "repoGetBootloader" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetBootloaderMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsRepo a) => O.MethodInfo RepoGetBootloaderMethodInfo a signature where + overloadedMethod _ = repoGetBootloader + +#endif + +-- method Repo::get_collection_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_collection_id" ostree_repo_get_collection_id :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CString + +{- | +Get the collection ID of this repository. See [collection IDs][collection-ids]. + +/Since: 2018.6/ +-} +repoGetCollectionId :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ collection ID for the repository -} +repoGetCollectionId self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_collection_id self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr self + return maybeResult + +#if ENABLE_OVERLOADING +data RepoGetCollectionIdMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRepo a) => O.MethodInfo RepoGetCollectionIdMethodInfo a signature where + overloadedMethod _ = repoGetCollectionId + +#endif + +-- method Repo::get_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_config" ostree_repo_get_config :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +repoGetConfig :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ The repository configuration; do not modify -} +repoGetConfig self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_config self' + checkUnexpectedReturnNULL "repoGetConfig" result + result' <- (newBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetConfigMethodInfo +instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsRepo a) => O.MethodInfo RepoGetConfigMethodInfo a signature where + overloadedMethod _ = repoGetConfig + +#endif + +-- method Repo::get_default_repo_finders +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_default_repo_finders" ostree_repo_get_default_repo_finders :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO (Ptr CString) + +{- | +Get the set of default repo finders configured. See the documentation for +the \"core.default-repo-finders\" config key. + +/Since: 2018.9/ +-} +repoGetDefaultRepoFinders :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> m [T.Text] + {- ^ __Returns:__ + 'Nothing'-terminated array of strings. -} +repoGetDefaultRepoFinders self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_default_repo_finders self' + checkUnexpectedReturnNULL "repoGetDefaultRepoFinders" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetDefaultRepoFindersMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsRepo a) => O.MethodInfo RepoGetDefaultRepoFindersMethodInfo a signature where + overloadedMethod _ = repoGetDefaultRepoFinders + +#endif + +-- method Repo::get_dfd +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_dfd" ostree_repo_get_dfd :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO Int32 + +{- | +In some cases it\'s useful for applications to access the repository +directly; for example, writing content into @repo\/tmp@ ensures it\'s +on the same filesystem. Another case is detecting the mtime on the +repository (to see whether a ref was written). +-} +repoGetDfd :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> m Int32 + {- ^ __Returns:__ File descriptor for repository root - owned by /@self@/ -} +repoGetDfd self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_dfd self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data RepoGetDfdMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsRepo a) => O.MethodInfo RepoGetDfdMethodInfo a signature where + overloadedMethod _ = repoGetDfd + +#endif + +-- method Repo::get_disable_fsync +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_disable_fsync" ostree_repo_get_disable_fsync :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CInt + +{- | +For more information see 'GI.OSTree.Objects.Repo.repoSetDisableFsync'. +-} +repoGetDisableFsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> m Bool + {- ^ __Returns:__ Whether or not @/fsync()/@ is enabled for this repo. -} +repoGetDisableFsync self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_disable_fsync self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetDisableFsyncMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRepo a) => O.MethodInfo RepoGetDisableFsyncMethodInfo a signature where + overloadedMethod _ = repoGetDisableFsync + +#endif + +-- method Repo::get_min_free_space_bytes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_reserved_bytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_get_min_free_space_bytes" ostree_repo_get_min_free_space_bytes :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Word64 -> -- out_reserved_bytes : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoGetMinFreeSpaceBytes :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + -> Word64 + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoGetMinFreeSpaceBytes self outReservedBytes = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ ostree_repo_get_min_free_space_bytes self' outReservedBytes + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoGetMinFreeSpaceBytesMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoGetMinFreeSpaceBytesMethodInfo a signature where + overloadedMethod _ = repoGetMinFreeSpaceBytes + +#endif + +-- method Repo::get_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_mode" ostree_repo_get_mode :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CUInt + +{- | +/No description available in the introspection data./ +-} +repoGetMode :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + -> m OSTree.Enums.RepoMode +repoGetMode self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_mode self' + let result' = (toEnum . fromIntegral) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetModeMethodInfo +instance (signature ~ (m OSTree.Enums.RepoMode), MonadIO m, IsRepo a) => O.MethodInfo RepoGetModeMethodInfo a signature where + overloadedMethod _ = repoGetMode + +#endif + +-- method Repo::get_parent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_parent" ostree_repo_get_parent :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO (Ptr Repo) + +{- | +Before this function can be used, @/ostree_repo_init()/@ must have been +called. +-} +repoGetParent :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> m Repo + {- ^ __Returns:__ Parent repository, or 'Nothing' if none -} +repoGetParent self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_parent self' + checkUnexpectedReturnNULL "repoGetParent" result + result' <- (newObject Repo) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetParentMethodInfo +instance (signature ~ (m Repo), MonadIO m, IsRepo a) => O.MethodInfo RepoGetParentMethodInfo a signature where + overloadedMethod _ = repoGetParent + +#endif + +-- method Repo::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_get_path" ostree_repo_get_path :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO (Ptr Gio.File.File) + +{- | +Note that since the introduction of 'GI.OSTree.Objects.Repo.repoOpenAt', this function may +return a process-specific path in @\/proc@ if the repository was created using +that API. In general, you should avoid use of this API. +-} +repoGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> m Gio.File.File + {- ^ __Returns:__ Path to repo -} +repoGetPath self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_get_path self' + checkUnexpectedReturnNULL "repoGetPath" result + result' <- (newObject Gio.File.File) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoGetPathMethodInfo +instance (signature ~ (m Gio.File.File), MonadIO m, IsRepo a) => O.MethodInfo RepoGetPathMethodInfo a signature where + overloadedMethod _ = repoGetPath + +#endif + +-- method Repo::get_remote_boolean_option +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value returned if @option_name is not present", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the result.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_get_remote_boolean_option" ostree_repo_get_remote_boolean_option :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + CString -> -- option_name : TBasicType TUTF8 + CInt -> -- default_value : TBasicType TBoolean + Ptr CInt -> -- out_value : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +OSTree remotes are represented by keyfile groups, formatted like: +@[remote \"remotename\"]@. This function returns a value named /@optionName@/ +underneath that group, and returns it as a boolean. +If the option is not set, /@outValue@/ will be set to /@defaultValue@/. If an +error is returned, /@outValue@/ will be set to 'False'. +-} +repoGetRemoteBooleanOption :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: A OstreeRepo -} + -> T.Text + {- ^ /@remoteName@/: Name -} + -> T.Text + {- ^ /@optionName@/: Option -} + -> Bool + {- ^ /@defaultValue@/: Value returned if /@optionName@/ is not present -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoGetRemoteBooleanOption self remoteName optionName defaultValue = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + optionName' <- textToCString optionName + let defaultValue' = (fromIntegral . fromEnum) defaultValue + outValue <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ ostree_repo_get_remote_boolean_option self' remoteName' optionName' defaultValue' outValue + outValue' <- peek outValue + let outValue'' = (/= 0) outValue' + touchManagedPtr self + freeMem remoteName' + freeMem optionName' + freeMem outValue + return outValue'' + ) (do + freeMem remoteName' + freeMem optionName' + freeMem outValue + ) + +#if ENABLE_OVERLOADING +data RepoGetRemoteBooleanOptionMethodInfo +instance (signature ~ (T.Text -> T.Text -> Bool -> m (Bool)), MonadIO m, IsRepo a) => O.MethodInfo RepoGetRemoteBooleanOptionMethodInfo a signature where + overloadedMethod _ = repoGetRemoteBooleanOption + +#endif + +-- method Repo::get_remote_list_option +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_value", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the list\n of strings. The list should be freed with\n g_strfreev().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_get_remote_list_option" ostree_repo_get_remote_list_option :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + CString -> -- option_name : TBasicType TUTF8 + Ptr (Ptr CString) -> -- out_value : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +OSTree remotes are represented by keyfile groups, formatted like: +@[remote \"remotename\"]@. This function returns a value named /@optionName@/ +underneath that group, and returns it as a zero terminated array of strings. +If the option is not set, or if an error is returned, /@outValue@/ will be set +to 'Nothing'. +-} +repoGetRemoteListOption :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: A OstreeRepo -} + -> T.Text + {- ^ /@remoteName@/: Name -} + -> T.Text + {- ^ /@optionName@/: Option -} + -> m ([T.Text]) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoGetRemoteListOption self remoteName optionName = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + optionName' <- textToCString optionName + outValue <- allocMem :: IO (Ptr (Ptr CString)) + onException (do + _ <- propagateGError $ ostree_repo_get_remote_list_option self' remoteName' optionName' outValue + outValue' <- peek outValue + outValue'' <- unpackZeroTerminatedUTF8CArray outValue' + mapZeroTerminatedCArray freeMem outValue' + freeMem outValue' + touchManagedPtr self + freeMem remoteName' + freeMem optionName' + freeMem outValue + return outValue'' + ) (do + freeMem remoteName' + freeMem optionName' + freeMem outValue + ) + +#if ENABLE_OVERLOADING +data RepoGetRemoteListOptionMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ([T.Text])), MonadIO m, IsRepo a) => O.MethodInfo RepoGetRemoteListOptionMethodInfo a signature where + overloadedMethod _ = repoGetRemoteListOption + +#endif + +-- method Repo::get_remote_option +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Value returned if @option_name is not present", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_get_remote_option" ostree_repo_get_remote_option :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + CString -> -- option_name : TBasicType TUTF8 + CString -> -- default_value : TBasicType TUTF8 + Ptr CString -> -- out_value : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +OSTree remotes are represented by keyfile groups, formatted like: +@[remote \"remotename\"]@. This function returns a value named /@optionName@/ +underneath that group, or /@defaultValue@/ if the remote exists but not the +option name. If an error is returned, /@outValue@/ will be set to 'Nothing'. +-} +repoGetRemoteOption :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: A OstreeRepo -} + -> T.Text + {- ^ /@remoteName@/: Name -} + -> T.Text + {- ^ /@optionName@/: Option -} + -> Maybe (T.Text) + {- ^ /@defaultValue@/: Value returned if /@optionName@/ is not present -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoGetRemoteOption self remoteName optionName defaultValue = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + optionName' <- textToCString optionName + maybeDefaultValue <- case defaultValue of + Nothing -> return nullPtr + Just jDefaultValue -> do + jDefaultValue' <- textToCString jDefaultValue + return jDefaultValue' + outValue <- allocMem :: IO (Ptr CString) + onException (do + _ <- propagateGError $ ostree_repo_get_remote_option self' remoteName' optionName' maybeDefaultValue outValue + outValue' <- peek outValue + outValue'' <- cstringToText outValue' + freeMem outValue' + touchManagedPtr self + freeMem remoteName' + freeMem optionName' + freeMem maybeDefaultValue + freeMem outValue + return outValue'' + ) (do + freeMem remoteName' + freeMem optionName' + freeMem maybeDefaultValue + freeMem outValue + ) + +#if ENABLE_OVERLOADING +data RepoGetRemoteOptionMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m (T.Text)), MonadIO m, IsRepo a) => O.MethodInfo RepoGetRemoteOptionMethodInfo a signature where + overloadedMethod _ = repoGetRemoteOption + +#endif + +-- method Repo::gpg_verify_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Data as a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signatures", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signatures as a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyringdir", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to directory GPG keyrings; overrides built-in default if given", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extra_keyring", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to additional keyring file (not a directory)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_gpg_verify_data" ostree_repo_gpg_verify_data :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + Ptr GLib.Bytes.Bytes -> -- data : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr GLib.Bytes.Bytes -> -- signatures : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr Gio.File.File -> -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult) + +{- | +Verify /@signatures@/ for /@data@/ using GPG keys in the keyring for +/@remoteName@/, and return an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'. + +The /@remoteName@/ parameter can be 'Nothing'. In that case it will do +the verifications using GPG keys in the keyrings of all remotes. +-} +repoGpgVerifyData :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: Repository -} + -> Maybe (T.Text) + {- ^ /@remoteName@/: Name of remote -} + -> GLib.Bytes.Bytes + {- ^ /@data@/: Data as a 'GI.GLib.Structs.Bytes.Bytes' -} + -> GLib.Bytes.Bytes + {- ^ /@signatures@/: Signatures as a 'GI.GLib.Structs.Bytes.Bytes' -} + -> Maybe (b) + {- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given -} + -> Maybe (c) + {- ^ /@extraKeyring@/: Path to additional keyring file (not a directory) -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m OSTree.GpgVerifyResult.GpgVerifyResult + {- ^ __Returns:__ an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoGpgVerifyData self remoteName data_ signatures keyringdir extraKeyring cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeRemoteName <- case remoteName of + Nothing -> return nullPtr + Just jRemoteName -> do + jRemoteName' <- textToCString jRemoteName + return jRemoteName' + data_' <- unsafeManagedPtrGetPtr data_ + signatures' <- unsafeManagedPtrGetPtr signatures + maybeKeyringdir <- case keyringdir of + Nothing -> return nullPtr + Just jKeyringdir -> do + jKeyringdir' <- unsafeManagedPtrCastPtr jKeyringdir + return jKeyringdir' + maybeExtraKeyring <- case extraKeyring of + Nothing -> return nullPtr + Just jExtraKeyring -> do + jExtraKeyring' <- unsafeManagedPtrCastPtr jExtraKeyring + return jExtraKeyring' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_gpg_verify_data self' maybeRemoteName data_' signatures' maybeKeyringdir maybeExtraKeyring maybeCancellable + checkUnexpectedReturnNULL "repoGpgVerifyData" result + result' <- (wrapObject OSTree.GpgVerifyResult.GpgVerifyResult) result + touchManagedPtr self + touchManagedPtr data_ + touchManagedPtr signatures + whenJust keyringdir touchManagedPtr + whenJust extraKeyring touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeRemoteName + return result' + ) (do + freeMem maybeRemoteName + ) + +#if ENABLE_OVERLOADING +data RepoGpgVerifyDataMethodInfo +instance (signature ~ (Maybe (T.Text) -> GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.MethodInfo RepoGpgVerifyDataMethodInfo a signature where + overloadedMethod _ = repoGpgVerifyData + +#endif + +-- method Repo::has_object +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_have_object", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if repository contains object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_has_object" ostree_repo_has_object :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr CInt -> -- out_have_object : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set /@outHaveObject@/ to 'True' if /@self@/ contains the given object; +'False' otherwise. +-} +repoHasObject :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: ASCII SHA256 checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoHasObject self objtype checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + outHaveObject <- allocMem :: IO (Ptr CInt) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_has_object self' objtype' checksum' outHaveObject maybeCancellable + outHaveObject' <- peek outHaveObject + let outHaveObject'' = (/= 0) outHaveObject' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem checksum' + freeMem outHaveObject + return outHaveObject'' + ) (do + freeMem checksum' + freeMem outHaveObject + ) + +#if ENABLE_OVERLOADING +data RepoHasObjectMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m (Bool)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoHasObjectMethodInfo a signature where + overloadedMethod _ = repoHasObject + +#endif + +-- method Repo::hash +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_hash" ostree_repo_hash :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO Word32 + +{- | +Calculate a hash value for the given open repository, suitable for use when +putting it into a hash table. It is an error to call this on an 'GI.OSTree.Objects.Repo.Repo' +which is not yet open, as a persistent hash value cannot be calculated until +the repository is open and the inode of its root directory has been loaded. + +This function does no I\/O. + +/Since: 2017.12/ +-} +repoHash :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> m Word32 + {- ^ __Returns:__ hash value for the 'GI.OSTree.Objects.Repo.Repo' -} +repoHash self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_hash self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data RepoHashMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsRepo a) => O.MethodInfo RepoHashMethodInfo a signature where + overloadedMethod _ = repoHash + +#endif + +-- method Repo::import_object_from +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Destination repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_import_object_from" ostree_repo_import_object_from :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Repo -> -- source : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Copy object named by /@objtype@/ and /@checksum@/ into /@self@/ from the +source repository /@source@/. If both repositories are of the same +type and on the same filesystem, this will simply be a fast Unix +hard link operation. + +Otherwise, a copy will be performed. +-} +repoImportObjectFrom :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Destination repo -} + -> b + {- ^ /@source@/: Source repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: checksum -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoImportObjectFrom self source objtype checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source' <- unsafeManagedPtrCastPtr source + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_import_object_from self' source' objtype' checksum' maybeCancellable + touchManagedPtr self + touchManagedPtr source + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoImportObjectFromMethodInfo +instance (signature ~ (b -> OSTree.Enums.ObjectType -> T.Text -> Maybe (c) -> m ()), MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoImportObjectFromMethodInfo a signature where + overloadedMethod _ = repoImportObjectFrom + +#endif + +-- method Repo::import_object_from_with_trust +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Destination repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, assume the source repo is valid and trusted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_import_object_from_with_trust" ostree_repo_import_object_from_with_trust :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Repo -> -- source : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + CInt -> -- trusted : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Copy object named by /@objtype@/ and /@checksum@/ into /@self@/ from the +source repository /@source@/. If /@trusted@/ is 'True' and both +repositories are of the same type and on the same filesystem, +this will simply be a fast Unix hard link operation. + +Otherwise, a copy will be performed. +-} +repoImportObjectFromWithTrust :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Destination repo -} + -> b + {- ^ /@source@/: Source repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: checksum -} + -> Bool + {- ^ /@trusted@/: If 'True', assume the source repo is valid and trusted -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoImportObjectFromWithTrust self source objtype checksum trusted cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source' <- unsafeManagedPtrCastPtr source + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + let trusted' = (fromIntegral . fromEnum) trusted + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_import_object_from_with_trust self' source' objtype' checksum' trusted' maybeCancellable + touchManagedPtr self + touchManagedPtr source + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoImportObjectFromWithTrustMethodInfo +instance (signature ~ (b -> OSTree.Enums.ObjectType -> T.Text -> Bool -> Maybe (c) -> m ()), MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoImportObjectFromWithTrustMethodInfo a signature where + overloadedMethod _ = repoImportObjectFromWithTrust + +#endif + +-- method Repo::is_system +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_is_system" ostree_repo_is_system :: + Ptr Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoIsSystem :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@repo@/: Repository -} + -> m Bool + {- ^ __Returns:__ 'True' if this repository is the root-owned system global repository -} +repoIsSystem repo = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + result <- ostree_repo_is_system repo' + let result' = (/= 0) result + touchManagedPtr repo + return result' + +#if ENABLE_OVERLOADING +data RepoIsSystemMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRepo a) => O.MethodInfo RepoIsSystemMethodInfo a signature where + overloadedMethod _ = repoIsSystem + +#endif + +-- method Repo::is_writable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_is_writable" ostree_repo_is_writable :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Returns whether the repository is writable by the current user. +If the repository is not writable, the /@error@/ indicates why. +-} +repoIsWritable :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoIsWritable self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ ostree_repo_is_writable self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoIsWritableMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoIsWritableMethodInfo a signature where + overloadedMethod _ = repoIsWritable + +#endif + +-- XXX Could not generate method Repo::list_collection_refs +-- Error was : Not implemented: "GHashTable element of type TInterface (Name {namespace = \"OSTree\", name = \"CollectionRef\"}) unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoListCollectionRefsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "listCollectionRefs" Repo) => O.MethodInfo RepoListCollectionRefsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::list_commit_objects_starting_with +-- Error was : Not implemented: "GHashTable element of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoListCommitObjectsStartingWithMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "listCommitObjectsStartingWith" Repo) => O.MethodInfo RepoListCommitObjectsStartingWithMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::list_objects +-- Error was : Not implemented: "GHashTable element of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoListObjectsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "listObjects" Repo) => O.MethodInfo RepoListObjectsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::list_refs +-- Error was : Not implemented: "Hash table argument with transfer = Container? outAllRefs'" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoListRefsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "listRefs" Repo) => O.MethodInfo RepoListRefsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::list_refs_ext +-- Error was : Not implemented: "Hash table argument with transfer = Container? outAllRefs'" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoListRefsExtMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "listRefsExt" Repo) => O.MethodInfo RepoListRefsExtMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method Repo::list_static_delta_names +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_deltas", argType = TPtrArray (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "String name of deltas (checksum-checksum.delta)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferContainer},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_list_static_delta_names" ostree_repo_list_static_delta_names :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr (Ptr (GPtrArray CString)) -> -- out_deltas : TPtrArray (TBasicType TUTF8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This function synchronously enumerates all static deltas in the +repository, returning its result in /@outDeltas@/. +-} +repoListStaticDeltaNames :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ([T.Text]) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoListStaticDeltaNames self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outDeltas <- allocMem :: IO (Ptr (Ptr (GPtrArray CString))) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_list_static_delta_names self' outDeltas maybeCancellable + outDeltas' <- peek outDeltas + outDeltas'' <- unpackGPtrArray outDeltas' + outDeltas''' <- mapM cstringToText outDeltas'' + unrefPtrArray outDeltas' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem outDeltas + return outDeltas''' + ) (do + freeMem outDeltas + ) + +#if ENABLE_OVERLOADING +data RepoListStaticDeltaNamesMethodInfo +instance (signature ~ (Maybe (b) -> m ([T.Text])), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoListStaticDeltaNamesMethodInfo a signature where + overloadedMethod _ = repoListStaticDeltaNames + +#endif + +-- method Repo::load_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Commit checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_commit", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_state", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitState"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Commit state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_load_commit" ostree_repo_load_commit :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr GVariant) -> -- out_commit : TVariant + Ptr CUInt -> -- out_state : TInterface (Name {namespace = "OSTree", name = "RepoCommitState"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +A version of 'GI.OSTree.Objects.Repo.repoLoadVariant' specialized to commits, +capable of returning extended state information. Currently +the only extended state is 'GI.OSTree.Flags.RepoCommitStatePartial', which +means that only a sub-path of the commit is available. +-} +repoLoadCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: Commit checksum -} + -> m ((GVariant, [OSTree.Flags.RepoCommitState])) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoLoadCommit self checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + outCommit <- allocMem :: IO (Ptr (Ptr GVariant)) + outState <- allocMem :: IO (Ptr CUInt) + onException (do + _ <- propagateGError $ ostree_repo_load_commit self' checksum' outCommit outState + outCommit' <- peek outCommit + outCommit'' <- B.GVariant.wrapGVariantPtr outCommit' + outState' <- peek outState + let outState'' = wordToGFlags outState' + touchManagedPtr self + freeMem checksum' + freeMem outCommit + freeMem outState + return (outCommit'', outState'') + ) (do + freeMem checksum' + freeMem outCommit + freeMem outState + ) + +#if ENABLE_OVERLOADING +data RepoLoadCommitMethodInfo +instance (signature ~ (T.Text -> m ((GVariant, [OSTree.Flags.RepoCommitState]))), MonadIO m, IsRepo a) => O.MethodInfo RepoLoadCommitMethodInfo a signature where + overloadedMethod _ = repoLoadCommit + +#endif + +-- method Repo::load_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_xattrs", argType = TVariant, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Extended attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_load_file" ostree_repo_load_file :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr (Ptr Gio.FileInfo.FileInfo) -> -- out_file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr (Ptr GVariant) -> -- out_xattrs : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Load content object, decomposing it into three parts: the actual +content (for regular files), the metadata, and extended attributes. +-} +repoLoadFile :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: ASCII SHA256 checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Maybe Gio.InputStream.InputStream, Maybe Gio.FileInfo.FileInfo, Maybe GVariant)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoLoadFile self checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outFileInfo <- allocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo)) + outXattrs <- allocMem :: IO (Ptr (Ptr GVariant)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_load_file self' checksum' outInput outFileInfo outXattrs maybeCancellable + outInput' <- peek outInput + maybeOutInput' <- convertIfNonNull outInput' $ \outInput'' -> do + outInput''' <- (wrapObject Gio.InputStream.InputStream) outInput'' + return outInput''' + outFileInfo' <- peek outFileInfo + maybeOutFileInfo' <- convertIfNonNull outFileInfo' $ \outFileInfo'' -> do + outFileInfo''' <- (wrapObject Gio.FileInfo.FileInfo) outFileInfo'' + return outFileInfo''' + outXattrs' <- peek outXattrs + maybeOutXattrs' <- convertIfNonNull outXattrs' $ \outXattrs'' -> do + outXattrs''' <- B.GVariant.wrapGVariantPtr outXattrs'' + return outXattrs''' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem checksum' + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + return (maybeOutInput', maybeOutFileInfo', maybeOutXattrs') + ) (do + freeMem checksum' + freeMem outInput + freeMem outFileInfo + freeMem outXattrs + ) + +#if ENABLE_OVERLOADING +data RepoLoadFileMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m ((Maybe Gio.InputStream.InputStream, Maybe Gio.FileInfo.FileInfo, Maybe GVariant))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoLoadFileMethodInfo a signature where + overloadedMethod _ = repoLoadFile + +#endif + +-- method Repo::load_object_stream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Stream for object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of @out_input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_load_object_stream" ostree_repo_load_object_stream :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr Word64 -> -- out_size : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Load object as a stream; useful when copying objects between +repositories. +-} +repoLoadObjectStream :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: ASCII SHA256 checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.InputStream.InputStream, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoLoadObjectStream self objtype checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + outInput <- allocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream)) + outSize <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_load_object_stream self' objtype' checksum' outInput outSize maybeCancellable + outInput' <- peek outInput + outInput'' <- (wrapObject Gio.InputStream.InputStream) outInput' + outSize' <- peek outSize + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem checksum' + freeMem outInput + freeMem outSize + return (outInput'', outSize') + ) (do + freeMem checksum' + freeMem outInput + freeMem outSize + ) + +#if ENABLE_OVERLOADING +data RepoLoadObjectStreamMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ((Gio.InputStream.InputStream, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoLoadObjectStreamMethodInfo a signature where + overloadedMethod _ = repoLoadObjectStream + +#endif + +-- method Repo::load_variant +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Expected object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_variant", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_load_variant" ostree_repo_load_variant :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- sha256 : TBasicType TUTF8 + Ptr (Ptr GVariant) -> -- out_variant : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Load the metadata object /@sha256@/ of type /@objtype@/, storing the +result in /@outVariant@/. +-} +repoLoadVariant :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Expected object type -} + -> T.Text + {- ^ /@sha256@/: Checksum string -} + -> m (GVariant) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoLoadVariant self objtype sha256 = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + sha256' <- textToCString sha256 + outVariant <- allocMem :: IO (Ptr (Ptr GVariant)) + onException (do + _ <- propagateGError $ ostree_repo_load_variant self' objtype' sha256' outVariant + outVariant' <- peek outVariant + outVariant'' <- B.GVariant.wrapGVariantPtr outVariant' + touchManagedPtr self + freeMem sha256' + freeMem outVariant + return outVariant'' + ) (do + freeMem sha256' + freeMem outVariant + ) + +#if ENABLE_OVERLOADING +data RepoLoadVariantMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> m (GVariant)), MonadIO m, IsRepo a) => O.MethodInfo RepoLoadVariantMethodInfo a signature where + overloadedMethod _ = repoLoadVariant + +#endif + +-- method Repo::load_variant_if_exists +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_variant", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_load_variant_if_exists" ostree_repo_load_variant_if_exists :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- sha256 : TBasicType TUTF8 + Ptr (Ptr GVariant) -> -- out_variant : TVariant + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Attempt to load the metadata object /@sha256@/ of type /@objtype@/ if it +exists, storing the result in /@outVariant@/. If it doesn\'t exist, +'Nothing' is returned. +-} +repoLoadVariantIfExists :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@sha256@/: ASCII checksum -} + -> m (GVariant) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoLoadVariantIfExists self objtype sha256 = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + sha256' <- textToCString sha256 + outVariant <- allocMem :: IO (Ptr (Ptr GVariant)) + onException (do + _ <- propagateGError $ ostree_repo_load_variant_if_exists self' objtype' sha256' outVariant + outVariant' <- peek outVariant + outVariant'' <- B.GVariant.wrapGVariantPtr outVariant' + touchManagedPtr self + freeMem sha256' + freeMem outVariant + return outVariant'' + ) (do + freeMem sha256' + freeMem outVariant + ) + +#if ENABLE_OVERLOADING +data RepoLoadVariantIfExistsMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> m (GVariant)), MonadIO m, IsRepo a) => O.MethodInfo RepoLoadVariantIfExistsMethodInfo a signature where + overloadedMethod _ = repoLoadVariantIfExists + +#endif + +-- method Repo::mark_commit_partial +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Commit SHA-256", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_partial", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not this commit is partial", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_mark_commit_partial" ostree_repo_mark_commit_partial :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + CInt -> -- is_partial : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Commits in \"partial\" state do not have all their child objects written. This +occurs in various situations, such as during a pull, but also if a \"subpath\" +pull is used, as well as \"commit only\" pulls. + +This function is used by 'GI.OSTree.Objects.Repo.repoPullWithOptions'; you +should use this if you are implementing a different type of transport. + +/Since: 2017.15/ +-} +repoMarkCommitPartial :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: Commit SHA-256 -} + -> Bool + {- ^ /@isPartial@/: Whether or not this commit is partial -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoMarkCommitPartial self checksum isPartial = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + let isPartial' = (fromIntegral . fromEnum) isPartial + onException (do + _ <- propagateGError $ ostree_repo_mark_commit_partial self' checksum' isPartial' + touchManagedPtr self + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoMarkCommitPartialMethodInfo +instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoMarkCommitPartialMethodInfo a signature where + overloadedMethod _ = repoMarkCommitPartial + +#endif + +-- method Repo::open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_open" ostree_repo_open :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + -> Maybe (b) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoOpen self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_open self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoOpenMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoOpenMethodInfo a signature where + overloadedMethod _ = repoOpen + +#endif + +-- method Repo::prepare_transaction +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_transaction_resume", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether this transaction\nis resuming from a previous one. This is a legacy state, now OSTree\npulls use per-commit `state/.commitpartial` files.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_prepare_transaction" ostree_repo_prepare_transaction :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr CInt -> -- out_transaction_resume : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Starts or resumes a transaction. In order to write to a repo, you +need to start a transaction. You can complete the transaction with +'GI.OSTree.Objects.Repo.repoCommitTransaction', or abort the transaction with +'GI.OSTree.Objects.Repo.repoAbortTransaction'. + +Currently, transactions may result in partial commits or data in the target +repository if interrupted during 'GI.OSTree.Objects.Repo.repoCommitTransaction', and +further writing refs is also not currently atomic. + +There can be at most one transaction active on a repo at a time per instance +of @OstreeRepo@; however, it is safe to have multiple threads writing objects +on a single @OstreeRepo@ instance as long as their lifetime is bounded by the +transaction. + +Locking: Acquires a @shared@ lock; release via commit or abort +Multithreading: This function is *not* MT safe; only one transaction can be +active at a time. +-} +repoPrepareTransaction :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPrepareTransaction self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outTransactionResume <- allocMem :: IO (Ptr CInt) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_prepare_transaction self' outTransactionResume maybeCancellable + outTransactionResume' <- peek outTransactionResume + let outTransactionResume'' = (/= 0) outTransactionResume' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem outTransactionResume + return outTransactionResume'' + ) (do + freeMem outTransactionResume + ) + +#if ENABLE_OVERLOADING +data RepoPrepareTransactionMethodInfo +instance (signature ~ (Maybe (b) -> m (Bool)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoPrepareTransactionMethodInfo a signature where + overloadedMethod _ = repoPrepareTransaction + +#endif + +-- method Repo::prune +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoPruneFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling prune process", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "depth", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Stop traversal after this many iterations (-1 for unlimited)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_objects_total", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_objects_pruned", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_pruned_object_size_total", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Storage size in bytes of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_prune" ostree_repo_prune :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPruneFlags"}) + Int32 -> -- depth : TBasicType TInt + Ptr Int32 -> -- out_objects_total : TBasicType TInt + Ptr Int32 -> -- out_objects_pruned : TBasicType TInt + Ptr Word64 -> -- out_pruned_object_size_total : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete content from the repository. By default, this function will +only delete \"orphaned\" objects not referred to by any commit. This +can happen during a local commit operation, when we have written +content objects but not saved the commit referencing them. + +However, if 'GI.OSTree.Enums.RepoPruneFlagsRefsOnly' is provided, instead +of traversing all commits, only refs will be used. Particularly +when combined with /@depth@/, this is a convenient way to delete +history from the repository. + +Use the 'GI.OSTree.Enums.RepoPruneFlagsNoPrune' to just determine +statistics on objects that would be deleted, without actually +deleting them. + +Locking: exclusive +-} +repoPrune :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.RepoPruneFlags + {- ^ /@flags@/: Options controlling prune process -} + -> Int32 + {- ^ /@depth@/: Stop traversal after this many iterations (-1 for unlimited) -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Int32, Int32, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPrune self flags depth cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let flags' = (fromIntegral . fromEnum) flags + outObjectsTotal <- allocMem :: IO (Ptr Int32) + outObjectsPruned <- allocMem :: IO (Ptr Int32) + outPrunedObjectSizeTotal <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_prune self' flags' depth outObjectsTotal outObjectsPruned outPrunedObjectSizeTotal maybeCancellable + outObjectsTotal' <- peek outObjectsTotal + outObjectsPruned' <- peek outObjectsPruned + outPrunedObjectSizeTotal' <- peek outPrunedObjectSizeTotal + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + return (outObjectsTotal', outObjectsPruned', outPrunedObjectSizeTotal') + ) (do + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + ) + +#if ENABLE_OVERLOADING +data RepoPruneMethodInfo +instance (signature ~ (OSTree.Enums.RepoPruneFlags -> Int32 -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoPruneMethodInfo a signature where + overloadedMethod _ = repoPrune + +#endif + +-- method Repo::prune_from_reachable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling prune process", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_objects_total", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_objects_pruned", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_pruned_object_size_total", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Storage size in bytes of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_prune_from_reachable" ostree_repo_prune_from_reachable :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.RepoPruneOptions.RepoPruneOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"}) + Ptr Int32 -> -- out_objects_total : TBasicType TInt + Ptr Int32 -> -- out_objects_pruned : TBasicType TInt + Ptr Word64 -> -- out_pruned_object_size_total : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete content from the repository. This function is the \"backend\" +half of the higher level 'GI.OSTree.Objects.Repo.repoPrune'. To use this function, +you determine the root set yourself, and this function finds all other +unreferenced objects and deletes them. + +Use this API when you want to perform more selective pruning - for example, +retain all commits from a production branch, but just GC some history from +your dev branch. + +The 'GI.OSTree.Enums.RepoPruneFlagsNoPrune' flag may be specified to just determine +statistics on objects that would be deleted, without actually deleting them. + +Locking: exclusive +-} +repoPruneFromReachable :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.RepoPruneOptions.RepoPruneOptions + {- ^ /@options@/: Options controlling prune process -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Int32, Int32, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPruneFromReachable self options cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + options' <- unsafeManagedPtrGetPtr options + outObjectsTotal <- allocMem :: IO (Ptr Int32) + outObjectsPruned <- allocMem :: IO (Ptr Int32) + outPrunedObjectSizeTotal <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_prune_from_reachable self' options' outObjectsTotal outObjectsPruned outPrunedObjectSizeTotal maybeCancellable + outObjectsTotal' <- peek outObjectsTotal + outObjectsPruned' <- peek outObjectsPruned + outPrunedObjectSizeTotal' <- peek outPrunedObjectSizeTotal + touchManagedPtr self + touchManagedPtr options + whenJust cancellable touchManagedPtr + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + return (outObjectsTotal', outObjectsPruned', outPrunedObjectSizeTotal') + ) (do + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + ) + +#if ENABLE_OVERLOADING +data RepoPruneFromReachableMethodInfo +instance (signature ~ (OSTree.RepoPruneOptions.RepoPruneOptions -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoPruneFromReachableMethodInfo a signature where + overloadedMethod _ = repoPruneFromReachable + +#endif + +-- method Repo::prune_static_deltas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum for commit, or %NULL for each\nnon existing commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_prune_static_deltas" ostree_repo_prune_static_deltas :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Prune static deltas, if COMMIT is specified then delete static delta files only +targeting that commit; otherwise any static delta of non existing commits are +deleted. + +Locking: exclusive +-} +repoPruneStaticDeltas :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> Maybe (T.Text) + {- ^ /@commit@/: ASCII SHA256 checksum for commit, or 'Nothing' for each +non existing commit -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPruneStaticDeltas self commit cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCommit <- case commit of + Nothing -> return nullPtr + Just jCommit -> do + jCommit' <- textToCString jCommit + return jCommit' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_prune_static_deltas self' maybeCommit maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem maybeCommit + return () + ) (do + freeMem maybeCommit + ) + +#if ENABLE_OVERLOADING +data RepoPruneStaticDeltasMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoPruneStaticDeltasMethodInfo a signature where + overloadedMethod _ = repoPruneStaticDeltas + +#endif + +-- method Repo::pull +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refs_to_fetch", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional list of refs; if %NULL, fetch all configured refs", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling fetch behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_pull" ostree_repo_pull :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + Ptr CString -> -- refs_to_fetch : TCArray True (-1) (-1) (TBasicType TUTF8) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}) + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Connect to the remote repository, fetching the specified set of +refs /@refsToFetch@/. For each ref that is changed, download the +commit, all metadata, and all content objects, storing them safely +on disk in /@self@/. + +If /@flags@/ contains 'GI.OSTree.Flags.RepoPullFlagsMirror', and +the /@refsToFetch@/ is 'Nothing', and the remote repository contains a +summary file, then all refs will be fetched. + +If /@flags@/ contains 'GI.OSTree.Flags.RepoPullFlagsCommitOnly', then only the +metadata for the commits in /@refsToFetch@/ is pulled. + +Warning: This API will iterate the thread default main context, +which is a bug, but kept for compatibility reasons. If you want to +avoid this, use 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault' to push a new +one around this call. +-} +repoPull :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@remoteName@/: Name of remote -} + -> Maybe ([T.Text]) + {- ^ /@refsToFetch@/: Optional list of refs; if 'Nothing', fetch all configured refs -} + -> [OSTree.Flags.RepoPullFlags] + {- ^ /@flags@/: Options controlling fetch behavior -} + -> Maybe (b) + {- ^ /@progress@/: Progress -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPull self remoteName refsToFetch flags progress cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + maybeRefsToFetch <- case refsToFetch of + Nothing -> return nullPtr + Just jRefsToFetch -> do + jRefsToFetch' <- packZeroTerminatedUTF8CArray jRefsToFetch + return jRefsToFetch' + let flags' = gflagsToWord flags + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_pull self' remoteName' maybeRefsToFetch flags' maybeProgress maybeCancellable + touchManagedPtr self + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem remoteName' + mapZeroTerminatedCArray freeMem maybeRefsToFetch + freeMem maybeRefsToFetch + return () + ) (do + freeMem remoteName' + mapZeroTerminatedCArray freeMem maybeRefsToFetch + freeMem maybeRefsToFetch + ) + +#if ENABLE_OVERLOADING +data RepoPullMethodInfo +instance (signature ~ (T.Text -> Maybe ([T.Text]) -> [OSTree.Flags.RepoPullFlags] -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoPullMethodInfo a signature where + overloadedMethod _ = repoPull + +#endif + +-- method Repo::pull_from_remotes_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "results", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%NULL-terminated array of remotes to\n pull from, including the refs to pull from each", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A GVariant `a{sv}` with an extensible set of flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an #OstreeAsyncProgress to update with the operation\8217s\n progress, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "asynchronous completion callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_pull_from_remotes_async" ostree_repo_pull_from_remotes_async :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr (Ptr OSTree.RepoFinderResult.RepoFinderResult) -> -- results : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"})) + Ptr GVariant -> -- options : TVariant + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Pull refs from multiple remotes which have been found using +'GI.OSTree.Objects.Repo.repoFindRemotesAsync'. + +/@results@/ are expected to be in priority order, with the best remotes to pull +from listed first. 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' will generally pull +from the remotes in order, but may parallelise its downloads. + +If an error is encountered when pulling from a given remote, that remote will +be ignored and another will be tried instead. If any refs have not been +downloaded successfully after all remotes have been tried, 'GI.Gio.Enums.IOErrorEnumFailed' +will be returned. The results of any successful downloads will remain cached +in the local repository. + +If /@cancellable@/ is cancelled, 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned +immediately. The results of any successfully completed downloads at that +point will remain cached in the local repository. + +GPG verification of commits will be used unconditionally. + +The following /@options@/ are currently defined: + + * @flags@ (@i@): 'GI.OSTree.Flags.RepoPullFlags' to apply to the pull operation + * @inherit-transaction@ (@b@): 'True' to inherit an ongoing transaction on + the 'GI.OSTree.Objects.Repo.Repo', rather than encapsulating the pull in a new one + * @depth@ (@i@): How far in the history to traverse; default is 0, -1 means infinite + * @disable-static-deltas@ (@b@): Do not use static deltas + * @http-headers@ (@a(ss)@): Additional headers to add to all HTTP requests + * @subdirs@ (@as@): Pull just these subdirectories + * @update-frequency@ (@u@): Frequency to call the async progress callback in + milliseconds, if any; only values higher than 0 are valid + * @append-user-agent@ (@s@): Additional string to append to the user agent + * @n-network-retries@ (@u@): Number of times to retry each download on receiving + a transient network error, such as a socket timeout; default is 5, 0 + means return errors without retrying. Since: 2018.6 + * @ref-keyring-map@ (@a(sss)@): Array of (collection ID, ref name, keyring + remote name) tuples specifying which remote\'s keyring should be used when + doing GPG verification of each collection-ref. This is useful to prevent a + remote from serving malicious updates to refs which did not originate from + it. This can be a subset or superset of the refs being pulled; any ref + not being pulled will be ignored and any ref without a keyring remote + will be verified with the keyring of the remote being pulled from. + Since: 2019.2 + +/Since: 2018.6/ +-} +repoPullFromRemotesAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> [OSTree.RepoFinderResult.RepoFinderResult] + {- ^ /@results@/: 'Nothing'-terminated array of remotes to + pull from, including the refs to pull from each -} + -> Maybe (GVariant) + {- ^ /@options@/: A GVariant @a{sv}@ with an extensible set of flags -} + -> Maybe (b) + {- ^ /@progress@/: an 'GI.OSTree.Objects.AsyncProgress.AsyncProgress' to update with the operation’s + progress, or 'Nothing' -} + -> Maybe (c) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: asynchronous completion callback -} + -> m () +repoPullFromRemotesAsync self results options progress cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + results' <- mapM unsafeManagedPtrGetPtr results + results'' <- packZeroTerminatedPtrArray results' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_pull_from_remotes_async self' results'' maybeOptions maybeProgress maybeCancellable maybeCallback userData + touchManagedPtr self + mapM_ touchManagedPtr results + whenJust options touchManagedPtr + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem results'' + return () + +#if ENABLE_OVERLOADING +data RepoPullFromRemotesAsyncMethodInfo +instance (signature ~ ([OSTree.RepoFinderResult.RepoFinderResult] -> Maybe (GVariant) -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoPullFromRemotesAsyncMethodInfo a signature where + overloadedMethod _ = repoPullFromRemotesAsync + +#endif + +-- method Repo::pull_from_remotes_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the asynchronous result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_pull_from_remotes_finish" ostree_repo_pull_from_remotes_finish :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous pull operation started with +'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync'. + +/Since: 2018.6/ +-} +repoPullFromRemotesFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> b + {- ^ /@result@/: the asynchronous result -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPullFromRemotesFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ ostree_repo_pull_from_remotes_finish self' result_' + touchManagedPtr self + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoPullFromRemotesFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RepoPullFromRemotesFinishMethodInfo a signature where + overloadedMethod _ = repoPullFromRemotesFinish + +#endif + +-- method Repo::pull_one_dir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir_to_pull", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Subdirectory path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refs_to_fetch", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional list of refs; if %NULL, fetch all configured refs", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling fetch behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_pull_one_dir" ostree_repo_pull_one_dir :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + CString -> -- dir_to_pull : TBasicType TUTF8 + Ptr CString -> -- refs_to_fetch : TCArray True (-1) (-1) (TBasicType TUTF8) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}) + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This is similar to 'GI.OSTree.Objects.Repo.repoPull', but only fetches a single +subpath. +-} +repoPullOneDir :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@remoteName@/: Name of remote -} + -> T.Text + {- ^ /@dirToPull@/: Subdirectory path -} + -> Maybe ([T.Text]) + {- ^ /@refsToFetch@/: Optional list of refs; if 'Nothing', fetch all configured refs -} + -> [OSTree.Flags.RepoPullFlags] + {- ^ /@flags@/: Options controlling fetch behavior -} + -> Maybe (b) + {- ^ /@progress@/: Progress -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPullOneDir self remoteName dirToPull refsToFetch flags progress cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + dirToPull' <- textToCString dirToPull + maybeRefsToFetch <- case refsToFetch of + Nothing -> return nullPtr + Just jRefsToFetch -> do + jRefsToFetch' <- packZeroTerminatedUTF8CArray jRefsToFetch + return jRefsToFetch' + let flags' = gflagsToWord flags + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_pull_one_dir self' remoteName' dirToPull' maybeRefsToFetch flags' maybeProgress maybeCancellable + touchManagedPtr self + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem remoteName' + freeMem dirToPull' + mapZeroTerminatedCArray freeMem maybeRefsToFetch + freeMem maybeRefsToFetch + return () + ) (do + freeMem remoteName' + freeMem dirToPull' + mapZeroTerminatedCArray freeMem maybeRefsToFetch + freeMem maybeRefsToFetch + ) + +#if ENABLE_OVERLOADING +data RepoPullOneDirMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe ([T.Text]) -> [OSTree.Flags.RepoPullFlags] -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoPullOneDirMethodInfo a signature where + overloadedMethod _ = repoPullOneDir + +#endif + +-- method Repo::pull_with_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name_or_baseurl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote or file:// url", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A GVariant a{sv} with an extensible set of flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_pull_with_options" ostree_repo_pull_with_options :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name_or_baseurl : TBasicType TUTF8 + Ptr GVariant -> -- options : TVariant + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.Repo.repoPull', but supports an extensible set of flags. +The following are currently defined: + + * refs (as): Array of string refs + * collection-refs (a(sss)): Array of (collection ID, ref name, checksum) tuples to pull; + mutually exclusive with @refs@ and @override-commit-ids@. Checksums may be the empty + string to pull the latest commit for that ref + * flags (i): An instance of 'GI.OSTree.Flags.RepoPullFlags' + * subdir (s): Pull just this subdirectory + * subdirs (as): Pull just these subdirectories + * override-remote-name (s): If local, add this remote to refspec + * gpg-verify (b): GPG verify commits + * gpg-verify-summary (b): GPG verify summary + * depth (i): How far in the history to traverse; default is 0, -1 means infinite + * disable-static-deltas (b): Do not use static deltas + * require-static-deltas (b): Require static deltas + * override-commit-ids (as): Array of specific commit IDs to fetch for refs + * timestamp-check (b): Verify commit timestamps are newer than current (when pulling via ref); Since: 2017.11 + * metadata-size-restriction (t): Restrict metadata objects to a maximum number of bytes; 0 to disable. Since: 2018.9 + * dry-run (b): Only print information on what will be downloaded (requires static deltas) + * override-url (s): Fetch objects from this URL if remote specifies no metalink in options + * inherit-transaction (b): Don\'t initiate, finish or abort a transaction, useful to do multiple pulls in one transaction. + * http-headers (a(ss)): Additional headers to add to all HTTP requests + * update-frequency (u): Frequency to call the async progress callback in milliseconds, if any; only values higher than 0 are valid + * localcache-repos (as): File paths for local repos to use as caches when doing remote fetches + * append-user-agent (s): Additional string to append to the user agent + * n-network-retries (u): Number of times to retry each download on receiving + a transient network error, such as a socket timeout; default is 5, 0 + means return errors without retrying. Since: 2018.6 + * ref-keyring-map (a(sss)): Array of (collection ID, ref name, keyring + remote name) tuples specifying which remote\'s keyring should be used when + doing GPG verification of each collection-ref. This is useful to prevent a + remote from serving malicious updates to refs which did not originate from + it. This can be a subset or superset of the refs being pulled; any ref + not being pulled will be ignored and any ref without a keyring remote + will be verified with the keyring of the remote being pulled from. + Since: 2019.2 +-} +repoPullWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@remoteNameOrBaseurl@/: Name of remote or file:\/\/ url -} + -> GVariant + {- ^ /@options@/: A GVariant a{sv} with an extensible set of flags. -} + -> Maybe (b) + {- ^ /@progress@/: Progress -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoPullWithOptions self remoteNameOrBaseurl options progress cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteNameOrBaseurl' <- textToCString remoteNameOrBaseurl + options' <- unsafeManagedPtrGetPtr options + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_pull_with_options self' remoteNameOrBaseurl' options' maybeProgress maybeCancellable + touchManagedPtr self + touchManagedPtr options + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem remoteNameOrBaseurl' + return () + ) (do + freeMem remoteNameOrBaseurl' + ) + +#if ENABLE_OVERLOADING +data RepoPullWithOptionsMethodInfo +instance (signature ~ (T.Text -> GVariant -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoPullWithOptionsMethodInfo a signature where + overloadedMethod _ = repoPullWithOptions + +#endif + +-- method Repo::query_object_storage_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sha256", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size in bytes object occupies physically", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_query_object_storage_size" ostree_repo_query_object_storage_size :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- sha256 : TBasicType TUTF8 + Ptr Word64 -> -- out_size : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Return the size in bytes of object with checksum /@sha256@/, after any +compression has been applied. +-} +repoQueryObjectStorageSize :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@sha256@/: Checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (Word64) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoQueryObjectStorageSize self objtype sha256 cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + sha256' <- textToCString sha256 + outSize <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_query_object_storage_size self' objtype' sha256' outSize maybeCancellable + outSize' <- peek outSize + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem sha256' + freeMem outSize + return outSize' + ) (do + freeMem sha256' + freeMem outSize + ) + +#if ENABLE_OVERLOADING +data RepoQueryObjectStorageSizeMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m (Word64)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoQueryObjectStorageSizeMethodInfo a signature where + overloadedMethod _ = repoQueryObjectStorageSize + +#endif + +-- method Repo::read_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Ref or ASCII checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_root", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepoFile corresponding to the root", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_commit", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The resolved commit checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_read_commit" ostree_repo_read_commit :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- ref : TBasicType TUTF8 + Ptr (Ptr Gio.File.File) -> -- out_root : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr CString -> -- out_commit : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Load the content for /@rev@/ into /@outRoot@/. +-} +repoReadCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@ref@/: Ref or ASCII checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Gio.File.File, T.Text)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoReadCommit self ref cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ref' <- textToCString ref + outRoot <- allocMem :: IO (Ptr (Ptr Gio.File.File)) + outCommit <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_read_commit self' ref' outRoot outCommit maybeCancellable + outRoot' <- peek outRoot + outRoot'' <- (wrapObject Gio.File.File) outRoot' + outCommit' <- peek outCommit + outCommit'' <- cstringToText outCommit' + freeMem outCommit' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem ref' + freeMem outRoot + freeMem outCommit + return (outRoot'', outCommit'') + ) (do + freeMem ref' + freeMem outRoot + freeMem outCommit + ) + +#if ENABLE_OVERLOADING +data RepoReadCommitMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m ((Gio.File.File, T.Text))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoReadCommitMethodInfo a signature where + overloadedMethod _ = repoReadCommit + +#endif + +-- method Repo::read_commit_detached_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 commit checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_metadata", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata associated with commit in with format \"a{sv}\", or %NULL if none exists", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_read_commit_detached_metadata" ostree_repo_read_commit_detached_metadata :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr (Ptr GVariant) -> -- out_metadata : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +OSTree commits can have arbitrary metadata associated; this +function retrieves them. If none exists, /@outMetadata@/ will be set +to 'Nothing'. +-} +repoReadCommitDetachedMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: ASCII SHA256 commit checksum -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (GVariant) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoReadCommitDetachedMetadata self checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + outMetadata <- allocMem :: IO (Ptr (Ptr GVariant)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_read_commit_detached_metadata self' checksum' outMetadata maybeCancellable + outMetadata' <- peek outMetadata + outMetadata'' <- B.GVariant.wrapGVariantPtr outMetadata' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem checksum' + freeMem outMetadata + return outMetadata'' + ) (do + freeMem checksum' + freeMem outMetadata + ) + +#if ENABLE_OVERLOADING +data RepoReadCommitDetachedMetadataMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m (GVariant)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoReadCommitDetachedMetadataMethodInfo a signature where + overloadedMethod _ = repoReadCommitDetachedMetadata + +#endif + +-- method Repo::regenerate_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "additional_metadata", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A GVariant of type a{sv}, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_regenerate_summary" ostree_repo_regenerate_summary :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr GVariant -> -- additional_metadata : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +An OSTree repository can contain a high level \"summary\" file that +describes the available branches and other metadata. + +If the timetable for making commits and updating the summary file is fairly +regular, setting the @ostree.summary.expires@ key in /@additionalMetadata@/ +will aid clients in working out when to check for updates. + +It is regenerated automatically after any ref is +added, removed, or updated if @core\/auto-update-summary@ is set. + +If the @core\/collection-id@ key is set in the configuration, it will be +included as @/OSTREE_SUMMARY_COLLECTION_ID/@ in the summary file. Refs that +have associated collection IDs will be included in the generated summary +file, listed under the @/OSTREE_SUMMARY_COLLECTION_MAP/@ key. Collection IDs +and refs in @/OSTREE_SUMMARY_COLLECTION_MAP/@ are guaranteed to be in +lexicographic order. + +Locking: exclusive +-} +repoRegenerateSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> Maybe (GVariant) + {- ^ /@additionalMetadata@/: A GVariant of type a{sv}, or 'Nothing' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRegenerateSummary self additionalMetadata cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeAdditionalMetadata <- case additionalMetadata of + Nothing -> return nullPtr + Just jAdditionalMetadata -> do + jAdditionalMetadata' <- unsafeManagedPtrGetPtr jAdditionalMetadata + return jAdditionalMetadata' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_regenerate_summary self' maybeAdditionalMetadata maybeCancellable + touchManagedPtr self + whenJust additionalMetadata touchManagedPtr + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoRegenerateSummaryMethodInfo +instance (signature ~ (Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoRegenerateSummaryMethodInfo a signature where + overloadedMethod _ = repoRegenerateSummary + +#endif + +-- method Repo::reload_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_reload_config" ostree_repo_reload_config :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +By default, an 'GI.OSTree.Objects.Repo.Repo' will cache the remote configuration and its +own repo\/config data. This API can be used to reload it. +-} +repoReloadConfig :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: repo -} + -> Maybe (b) + {- ^ /@cancellable@/: cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoReloadConfig self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_reload_config self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoReloadConfigMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoReloadConfigMethodInfo a signature where + overloadedMethod _ = repoReloadConfig + +#endif + +-- method Repo::remote_add +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URL for remote (if URL begins with metalink=, it will be used as such)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GVariant of type a{sv}", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_add" ostree_repo_remote_add :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- url : TBasicType TUTF8 + Ptr GVariant -> -- options : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Create a new remote named /@name@/ pointing to /@url@/. If /@options@/ is +provided, then it will be mapped to 'GI.GLib.Structs.KeyFile.KeyFile' entries, where the +GVariant dictionary key is an option string, and the value is +mapped as follows: + * s: 'GI.GLib.Structs.KeyFile.keyFileSetString' + * b: 'GI.GLib.Structs.KeyFile.keyFileSetBoolean' + * as: 'GI.GLib.Structs.KeyFile.keyFileSetStringList' +-} +repoRemoteAdd :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> T.Text + {- ^ /@url@/: URL for remote (if URL begins with metalink=, it will be used as such) -} + -> Maybe (GVariant) + {- ^ /@options@/: GVariant of type a{sv} -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteAdd self name url options cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + url' <- textToCString url + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_add self' name' url' maybeOptions maybeCancellable + touchManagedPtr self + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem name' + freeMem url' + return () + ) (do + freeMem name' + freeMem url' + ) + +#if ENABLE_OVERLOADING +data RepoRemoteAddMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoRemoteAddMethodInfo a signature where + overloadedMethod _ = repoRemoteAdd + +#endif + +-- method Repo::remote_change +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "System root", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "changeop", argType = TInterface (Name {namespace = "OSTree", name = "RepoRemoteChange"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Operation to perform", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URL for remote (if URL begins with metalink=, it will be used as such)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GVariant of type a{sv}", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_change" ostree_repo_remote_change :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.File.File -> -- sysroot : TInterface (Name {namespace = "Gio", name = "File"}) + CUInt -> -- changeop : TInterface (Name {namespace = "OSTree", name = "RepoRemoteChange"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- url : TBasicType TUTF8 + Ptr GVariant -> -- options : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +A combined function handling the equivalent of +'GI.OSTree.Objects.Repo.repoRemoteAdd', 'GI.OSTree.Objects.Repo.repoRemoteDelete', with more +options. +-} +repoRemoteChange :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Maybe (b) + {- ^ /@sysroot@/: System root -} + -> OSTree.Enums.RepoRemoteChange + {- ^ /@changeop@/: Operation to perform -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> T.Text + {- ^ /@url@/: URL for remote (if URL begins with metalink=, it will be used as such) -} + -> Maybe (GVariant) + {- ^ /@options@/: GVariant of type a{sv} -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteChange self sysroot changeop name url options cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeSysroot <- case sysroot of + Nothing -> return nullPtr + Just jSysroot -> do + jSysroot' <- unsafeManagedPtrCastPtr jSysroot + return jSysroot' + let changeop' = (fromIntegral . fromEnum) changeop + name' <- textToCString name + url' <- textToCString url + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_change self' maybeSysroot changeop' name' url' maybeOptions maybeCancellable + touchManagedPtr self + whenJust sysroot touchManagedPtr + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem name' + freeMem url' + return () + ) (do + freeMem name' + freeMem url' + ) + +#if ENABLE_OVERLOADING +data RepoRemoteChangeMethodInfo +instance (signature ~ (Maybe (b) -> OSTree.Enums.RepoRemoteChange -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoRemoteChangeMethodInfo a signature where + overloadedMethod _ = repoRemoteChange + +#endif + +-- method Repo::remote_delete +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_delete" ostree_repo_remote_delete :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete the remote named /@name@/. It is an error if the provided +remote does not exist. +-} +repoRemoteDelete :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteDelete self name cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_delete self' name' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepoRemoteDeleteMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoRemoteDeleteMethodInfo a signature where + overloadedMethod _ = repoRemoteDelete + +#endif + +-- method Repo::remote_fetch_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of a remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_summary", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for raw summary data, or\n %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_signatures", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for raw summary\n signature data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_fetch_summary" ostree_repo_remote_fetch_summary :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GLib.Bytes.Bytes) -> -- out_summary : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr (Ptr GLib.Bytes.Bytes) -> -- out_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Tries to fetch the summary file and any GPG signatures on the summary file +over HTTP, and returns the binary data in /@outSummary@/ and /@outSignatures@/ +respectively. + +If no summary file exists on the remote server, /@outSummary@/ is set to +/@nULL@/. Likewise if the summary file is not signed, /@outSignatures@/ is +set to /@nULL@/. In either case the function still returns 'True'. + +This method does not verify the signature of the downloaded summary file. +Use 'GI.OSTree.Objects.Repo.repoVerifySummary' for that. + +Parse the summary data into a 'GVariant' using 'GI.GLib.Structs.Variant.variantNewFromBytes' +with @/OSTREE_SUMMARY_GVARIANT_FORMAT/@ as the format string. +-} +repoRemoteFetchSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@name@/: name of a remote -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteFetchSummary self name cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outSummary <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes)) + outSignatures <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_fetch_summary self' name' outSummary outSignatures maybeCancellable + outSummary' <- peek outSummary + outSummary'' <- (wrapBoxed GLib.Bytes.Bytes) outSummary' + outSignatures' <- peek outSignatures + outSignatures'' <- (wrapBoxed GLib.Bytes.Bytes) outSignatures' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem name' + freeMem outSummary + freeMem outSignatures + return (outSummary'', outSignatures'') + ) (do + freeMem name' + freeMem outSummary + freeMem outSignatures + ) + +#if ENABLE_OVERLOADING +data RepoRemoteFetchSummaryMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoRemoteFetchSummaryMethodInfo a signature where + overloadedMethod _ = repoRemoteFetchSummary + +#endif + +-- method Repo::remote_fetch_summary_with_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of a remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A GVariant a{sv} with an extensible set of flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_summary", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for raw summary data, or\n %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_signatures", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for raw summary\n signature data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_fetch_summary_with_options" ostree_repo_remote_fetch_summary_with_options :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr GVariant -> -- options : TVariant + Ptr (Ptr GLib.Bytes.Bytes) -> -- out_summary : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr (Ptr GLib.Bytes.Bytes) -> -- out_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.Repo.repoRemoteFetchSummary', but supports an extensible set of flags. +The following are currently defined: + +* override-url (s): Fetch summary from this URL if remote specifies no metalink in options +* http-headers (a(ss)): Additional headers to add to all HTTP requests +* append-user-agent (s): Additional string to append to the user agent +* n-network-retries (u): Number of times to retry each download on receiving +a transient network error, such as a socket timeout; default is 5, 0 +means return errors without retrying +-} +repoRemoteFetchSummaryWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@name@/: name of a remote -} + -> Maybe (GVariant) + {- ^ /@options@/: A GVariant a{sv} with an extensible set of flags -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteFetchSummaryWithOptions self name options cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + outSummary <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes)) + outSignatures <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_fetch_summary_with_options self' name' maybeOptions outSummary outSignatures maybeCancellable + outSummary' <- peek outSummary + outSummary'' <- (wrapBoxed GLib.Bytes.Bytes) outSummary' + outSignatures' <- peek outSignatures + outSignatures'' <- (wrapBoxed GLib.Bytes.Bytes) outSignatures' + touchManagedPtr self + whenJust options touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem name' + freeMem outSummary + freeMem outSignatures + return (outSummary'', outSignatures'') + ) (do + freeMem name' + freeMem outSummary + freeMem outSignatures + ) + +#if ENABLE_OVERLOADING +data RepoRemoteFetchSummaryWithOptionsMethodInfo +instance (signature ~ (T.Text -> Maybe (GVariant) -> Maybe (b) -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoRemoteFetchSummaryWithOptionsMethodInfo a signature where + overloadedMethod _ = repoRemoteFetchSummaryWithOptions + +#endif + +-- method Repo::remote_get_gpg_verify +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_gpg_verify", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Remote's GPG option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_get_gpg_verify" ostree_repo_remote_get_gpg_verify :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr CInt -> -- out_gpg_verify : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Return whether GPG verification is enabled for the remote named /@name@/ +through /@outGpgVerify@/. It is an error if the provided remote does +not exist. +-} +repoRemoteGetGpgVerify :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteGetGpgVerify self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outGpgVerify <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ ostree_repo_remote_get_gpg_verify self' name' outGpgVerify + outGpgVerify' <- peek outGpgVerify + let outGpgVerify'' = (/= 0) outGpgVerify' + touchManagedPtr self + freeMem name' + freeMem outGpgVerify + return outGpgVerify'' + ) (do + freeMem name' + freeMem outGpgVerify + ) + +#if ENABLE_OVERLOADING +data RepoRemoteGetGpgVerifyMethodInfo +instance (signature ~ (T.Text -> m (Bool)), MonadIO m, IsRepo a) => O.MethodInfo RepoRemoteGetGpgVerifyMethodInfo a signature where + overloadedMethod _ = repoRemoteGetGpgVerify + +#endif + +-- method Repo::remote_get_gpg_verify_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_gpg_verify_summary", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Remote's GPG option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_get_gpg_verify_summary" ostree_repo_remote_get_gpg_verify_summary :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr CInt -> -- out_gpg_verify_summary : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Return whether GPG verification of the summary is enabled for the remote +named /@name@/ through /@outGpgVerifySummary@/. It is an error if the provided +remote does not exist. +-} +repoRemoteGetGpgVerifySummary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteGetGpgVerifySummary self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outGpgVerifySummary <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ ostree_repo_remote_get_gpg_verify_summary self' name' outGpgVerifySummary + outGpgVerifySummary' <- peek outGpgVerifySummary + let outGpgVerifySummary'' = (/= 0) outGpgVerifySummary' + touchManagedPtr self + freeMem name' + freeMem outGpgVerifySummary + return outGpgVerifySummary'' + ) (do + freeMem name' + freeMem outGpgVerifySummary + ) + +#if ENABLE_OVERLOADING +data RepoRemoteGetGpgVerifySummaryMethodInfo +instance (signature ~ (T.Text -> m (Bool)), MonadIO m, IsRepo a) => O.MethodInfo RepoRemoteGetGpgVerifySummaryMethodInfo a signature where + overloadedMethod _ = repoRemoteGetGpgVerifySummary + +#endif + +-- method Repo::remote_get_url +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_url", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Remote's URL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_get_url" ostree_repo_remote_get_url :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr CString -> -- out_url : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Return the URL of the remote named /@name@/ through /@outUrl@/. It is an +error if the provided remote does not exist. +-} +repoRemoteGetUrl :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@name@/: Name of remote -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteGetUrl self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + outUrl <- allocMem :: IO (Ptr CString) + onException (do + _ <- propagateGError $ ostree_repo_remote_get_url self' name' outUrl + outUrl' <- peek outUrl + outUrl'' <- cstringToText outUrl' + freeMem outUrl' + touchManagedPtr self + freeMem name' + freeMem outUrl + return outUrl'' + ) (do + freeMem name' + freeMem outUrl + ) + +#if ENABLE_OVERLOADING +data RepoRemoteGetUrlMethodInfo +instance (signature ~ (T.Text -> m (T.Text)), MonadIO m, IsRepo a) => O.MethodInfo RepoRemoteGetUrlMethodInfo a signature where + overloadedMethod _ = repoRemoteGetUrl + +#endif + +-- method Repo::remote_gpg_import +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of a remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GInputStream, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key_ids", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL-terminated array of GPG key IDs, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_imported", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "return location for the number of imported\n keys, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_remote_gpg_import" ostree_repo_remote_gpg_import :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- name : TBasicType TUTF8 + Ptr Gio.InputStream.InputStream -> -- source_stream : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Ptr CString -> -- key_ids : TCArray True (-1) (-1) (TBasicType TUTF8) + Word32 -> -- out_imported : TBasicType TUInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Imports one or more GPG keys from the open /@sourceStream@/, or from the +user\'s personal keyring if /@sourceStream@/ is 'Nothing'. The /@keyIds@/ array +can optionally restrict which keys are imported. If /@keyIds@/ is 'Nothing', +then all keys are imported. + +The imported keys will be used to conduct GPG verification when pulling +from the remote named /@name@/. +-} +repoRemoteGpgImport :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@name@/: name of a remote -} + -> Maybe (b) + {- ^ /@sourceStream@/: a 'GI.Gio.Objects.InputStream.InputStream', or 'Nothing' -} + -> Maybe ([T.Text]) + {- ^ /@keyIds@/: a 'Nothing'-terminated array of GPG key IDs, or 'Nothing' -} + -> Word32 + {- ^ /@outImported@/: return location for the number of imported + keys, or 'Nothing' -} + -> Maybe (c) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoRemoteGpgImport self name sourceStream keyIds outImported cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + maybeSourceStream <- case sourceStream of + Nothing -> return nullPtr + Just jSourceStream -> do + jSourceStream' <- unsafeManagedPtrCastPtr jSourceStream + return jSourceStream' + maybeKeyIds <- case keyIds of + Nothing -> return nullPtr + Just jKeyIds -> do + jKeyIds' <- packZeroTerminatedUTF8CArray jKeyIds + return jKeyIds' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_remote_gpg_import self' name' maybeSourceStream maybeKeyIds outImported maybeCancellable + touchManagedPtr self + whenJust sourceStream touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem name' + mapZeroTerminatedCArray freeMem maybeKeyIds + freeMem maybeKeyIds + return () + ) (do + freeMem name' + mapZeroTerminatedCArray freeMem maybeKeyIds + freeMem maybeKeyIds + ) + +#if ENABLE_OVERLOADING +data RepoRemoteGpgImportMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe ([T.Text]) -> Word32 -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoRemoteGpgImportMethodInfo a signature where + overloadedMethod _ = repoRemoteGpgImport + +#endif + +-- method Repo::remote_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_n_remotes", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of remotes available", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "out_n_remotes", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of remotes available", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TCArray False (-1) 1 (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_remote_list" ostree_repo_remote_list :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Word32 -> -- out_n_remotes : TBasicType TUInt + IO (Ptr CString) + +{- | +List available remote names in an 'GI.OSTree.Objects.Repo.Repo'. Remote names are sorted +alphabetically. If no remotes are available the function returns 'Nothing'. +-} +repoRemoteList :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> m [T.Text] + {- ^ __Returns:__ a 'Nothing'-terminated + array of remote names -} +repoRemoteList self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outNRemotes <- allocMem :: IO (Ptr Word32) + result <- ostree_repo_remote_list self' outNRemotes + outNRemotes' <- peek outNRemotes + checkUnexpectedReturnNULL "repoRemoteList" result + result' <- (unpackUTF8CArrayWithLength outNRemotes') result + (mapCArrayWithLength outNRemotes') freeMem result + freeMem result + touchManagedPtr self + freeMem outNRemotes + return result' + +#if ENABLE_OVERLOADING +data RepoRemoteListMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsRepo a) => O.MethodInfo RepoRemoteListMethodInfo a signature where + overloadedMethod _ = repoRemoteList + +#endif + +-- XXX Could not generate method Repo::remote_list_collection_refs +-- Error was : Not implemented: "GHashTable element of type TInterface (Name {namespace = \"OSTree\", name = \"CollectionRef\"}) unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoRemoteListCollectionRefsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "remoteListCollectionRefs" Repo) => O.MethodInfo RepoRemoteListCollectionRefsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::remote_list_refs +-- Error was : Not implemented: "Hash table argument with transfer = Container? outAllRefs'" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoRemoteListRefsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "remoteListRefs" Repo) => O.MethodInfo RepoRemoteListRefsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method Repo::resolve_collection_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TInterface (Name {namespace = "OSTree", name = "CollectionRef"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a collection\8211ref to resolve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_noent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to not throw an error if @ref doesn\8217t exist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "options controlling behaviour", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_rev", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "return location for\n the checksum corresponding to @ref, or %NULL if @allow_noent is %TRUE and\n the @ref could not be found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_resolve_collection_ref" ostree_repo_resolve_collection_ref :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) + CInt -> -- allow_noent : TBasicType TBoolean + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"}) + Ptr CString -> -- out_rev : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Look up the checksum for the given collection–ref, returning it in /@outRev@/. +This will search through the mirrors and remote refs. + +If /@allowNoent@/ is 'True' and the given /@ref@/ cannot be found, 'True' will be +returned and /@outRev@/ will be set to 'Nothing'. If /@allowNoent@/ is 'False' and +the given /@ref@/ cannot be found, a 'GI.Gio.Enums.IOErrorEnumNotFound' error will be +returned. + +If you want to check only local refs, not remote or mirrored ones, use the +flag 'GI.OSTree.Flags.RepoResolveRevExtFlagsLocalOnly'. This is analogous to using +'GI.OSTree.Objects.Repo.repoResolveRevExt' but for collection-refs. + +/Since: 2018.6/ +-} +repoResolveCollectionRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> OSTree.CollectionRef.CollectionRef + {- ^ /@ref@/: a collection–ref to resolve -} + -> Bool + {- ^ /@allowNoent@/: 'True' to not throw an error if /@ref@/ doesn’t exist -} + -> [OSTree.Flags.RepoResolveRevExtFlags] + {- ^ /@flags@/: options controlling behaviour -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> m ((Maybe T.Text)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoResolveCollectionRef self ref allowNoent flags cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ref' <- unsafeManagedPtrGetPtr ref + let allowNoent' = (fromIntegral . fromEnum) allowNoent + let flags' = gflagsToWord flags + outRev <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_resolve_collection_ref self' ref' allowNoent' flags' outRev maybeCancellable + outRev' <- peek outRev + maybeOutRev' <- convertIfNonNull outRev' $ \outRev'' -> do + outRev''' <- cstringToText outRev'' + return outRev''' + freeMem outRev' + touchManagedPtr self + touchManagedPtr ref + whenJust cancellable touchManagedPtr + freeMem outRev + return maybeOutRev' + ) (do + freeMem outRev + ) + +#if ENABLE_OVERLOADING +data RepoResolveCollectionRefMethodInfo +instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Bool -> [OSTree.Flags.RepoResolveRevExtFlags] -> Maybe (b) -> m ((Maybe T.Text))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoResolveCollectionRefMethodInfo a signature where + overloadedMethod _ = repoResolveCollectionRef + +#endif + +-- method Repo::resolve_keyring_for_collection +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the collection ID to look up a keyring for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Remote"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_resolve_keyring_for_collection" ostree_repo_resolve_keyring_for_collection :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- collection_id : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr OSTree.Remote.Remote) + +{- | +Find the GPG keyring for the given /@collectionId@/, using the local +configuration from the given 'GI.OSTree.Objects.Repo.Repo'. This will search the configured +remotes for ones whose @collection-id@ key matches /@collectionId@/, and will +return the first matching remote. + +If multiple remotes match and have different keyrings, a debug message will +be emitted, and the first result will be returned. It is expected that the +keyrings should match. + +If no match can be found, a 'GI.Gio.Enums.IOErrorEnumNotFound' error will be returned. + +/Since: 2018.6/ +-} +repoResolveKeyringForCollection :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> T.Text + {- ^ /@collectionId@/: the collection ID to look up a keyring for -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> m OSTree.Remote.Remote + {- ^ __Returns:__ 'GI.OSTree.Structs.Remote.Remote' containing the GPG keyring for + /@collectionId@/ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoResolveKeyringForCollection self collectionId cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + collectionId' <- textToCString collectionId + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_resolve_keyring_for_collection self' collectionId' maybeCancellable + checkUnexpectedReturnNULL "repoResolveKeyringForCollection" result + result' <- (wrapBoxed OSTree.Remote.Remote) result + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem collectionId' + return result' + ) (do + freeMem collectionId' + ) + +#if ENABLE_OVERLOADING +data RepoResolveKeyringForCollectionMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m OSTree.Remote.Remote), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoResolveKeyringForCollectionMethodInfo a signature where + overloadedMethod _ = repoResolveKeyringForCollection + +#endif + +-- method Repo::resolve_rev +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A refspec", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_noent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Do not throw an error if refspec does not exist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_rev", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A checksum,or %NULL if @allow_noent is true and it does not exist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_resolve_rev" ostree_repo_resolve_rev :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- refspec : TBasicType TUTF8 + CInt -> -- allow_noent : TBasicType TBoolean + Ptr CString -> -- out_rev : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Look up the given refspec, returning the checksum it references in +the parameter /@outRev@/. Will fall back on remote directory if cannot +find the given refspec in local. +-} +repoResolveRev :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@refspec@/: A refspec -} + -> Bool + {- ^ /@allowNoent@/: Do not throw an error if refspec does not exist -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoResolveRev self refspec allowNoent = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refspec' <- textToCString refspec + let allowNoent' = (fromIntegral . fromEnum) allowNoent + outRev <- allocMem :: IO (Ptr CString) + onException (do + _ <- propagateGError $ ostree_repo_resolve_rev self' refspec' allowNoent' outRev + outRev' <- peek outRev + outRev'' <- cstringToText outRev' + freeMem outRev' + touchManagedPtr self + freeMem refspec' + freeMem outRev + return outRev'' + ) (do + freeMem refspec' + freeMem outRev + ) + +#if ENABLE_OVERLOADING +data RepoResolveRevMethodInfo +instance (signature ~ (T.Text -> Bool -> m (T.Text)), MonadIO m, IsRepo a) => O.MethodInfo RepoResolveRevMethodInfo a signature where + overloadedMethod _ = repoResolveRev + +#endif + +-- method Repo::resolve_rev_ext +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A refspec", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_noent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Do not throw an error if refspec does not exist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options controlling behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_rev", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A checksum,or %NULL if @allow_noent is true and it does not exist", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_resolve_rev_ext" ostree_repo_resolve_rev_ext :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- refspec : TBasicType TUTF8 + CInt -> -- allow_noent : TBasicType TBoolean + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"}) + Ptr CString -> -- out_rev : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Look up the given refspec, returning the checksum it references in +the parameter /@outRev@/. Differently from 'GI.OSTree.Objects.Repo.repoResolveRev', +this will not fall back to searching through remote repos if a +local ref is specified but not found. + +The flag 'GI.OSTree.Flags.RepoResolveRevExtFlagsLocalOnly' is implied so +using it has no effect. +-} +repoResolveRevExt :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@refspec@/: A refspec -} + -> Bool + {- ^ /@allowNoent@/: Do not throw an error if refspec does not exist -} + -> [OSTree.Flags.RepoResolveRevExtFlags] + {- ^ /@flags@/: Options controlling behavior -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoResolveRevExt self refspec allowNoent flags = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refspec' <- textToCString refspec + let allowNoent' = (fromIntegral . fromEnum) allowNoent + let flags' = gflagsToWord flags + outRev <- allocMem :: IO (Ptr CString) + onException (do + _ <- propagateGError $ ostree_repo_resolve_rev_ext self' refspec' allowNoent' flags' outRev + outRev' <- peek outRev + outRev'' <- cstringToText outRev' + freeMem outRev' + touchManagedPtr self + freeMem refspec' + freeMem outRev + return outRev'' + ) (do + freeMem refspec' + freeMem outRev + ) + +#if ENABLE_OVERLOADING +data RepoResolveRevExtMethodInfo +instance (signature ~ (T.Text -> Bool -> [OSTree.Flags.RepoResolveRevExtFlags] -> m (T.Text)), MonadIO m, IsRepo a) => O.MethodInfo RepoResolveRevExtMethodInfo a signature where + overloadedMethod _ = repoResolveRevExt + +#endif + +-- method Repo::scan_hardlinks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_scan_hardlinks" ostree_repo_scan_hardlinks :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This function is deprecated in favor of using 'GI.OSTree.Structs.RepoDevInoCache.repoDevInoCacheNew', +which allows a precise mapping to be built up between hardlink checkout files +and their checksums between @ostree_repo_checkout_at()@ and +@ostree_repo_write_directory_to_mtree()@. + +When invoking 'GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree', it has to compute the +checksum of all files. If your commit contains hardlinks from a checkout, +this functions builds a mapping of device numbers and inodes to their +checksum. + +There is an upfront cost to creating this mapping, as this will scan the +entire objects directory. If your commit is composed of mostly hardlinks to +existing ostree objects, then this will speed up considerably, so call it +before you call 'GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree' or similar. However, +'GI.OSTree.Structs.RepoDevInoCache.repoDevInoCacheNew' is better as it avoids scanning all objects. + +Multithreading: This function is *not* MT safe. +-} +repoScanHardlinks :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoScanHardlinks self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_scan_hardlinks self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoScanHardlinksMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoScanHardlinksMethodInfo a signature where + overloadedMethod _ = repoScanHardlinks + +#endif + +-- method Repo::set_alias_ref_immediate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A remote for the ref", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The ref to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The ref target to point it to, or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_set_alias_ref_immediate" ostree_repo_set_alias_ref_immediate :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote : TBasicType TUTF8 + CString -> -- ref : TBasicType TUTF8 + CString -> -- target : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.Repo.repoSetRefImmediate', but creates an alias. +-} +repoSetAliasRefImmediate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (T.Text) + {- ^ /@remote@/: A remote for the ref -} + -> T.Text + {- ^ /@ref@/: The ref to write -} + -> Maybe (T.Text) + {- ^ /@target@/: The ref target to point it to, or 'Nothing' to unset -} + -> Maybe (b) + {- ^ /@cancellable@/: GCancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSetAliasRefImmediate self remote ref target cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeRemote <- case remote of + Nothing -> return nullPtr + Just jRemote -> do + jRemote' <- textToCString jRemote + return jRemote' + ref' <- textToCString ref + maybeTarget <- case target of + Nothing -> return nullPtr + Just jTarget -> do + jTarget' <- textToCString jTarget + return jTarget' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_set_alias_ref_immediate self' maybeRemote ref' maybeTarget maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem maybeRemote + freeMem ref' + freeMem maybeTarget + return () + ) (do + freeMem maybeRemote + freeMem ref' + freeMem maybeTarget + ) + +#if ENABLE_OVERLOADING +data RepoSetAliasRefImmediateMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSetAliasRefImmediateMethodInfo a signature where + overloadedMethod _ = repoSetAliasRefImmediate + +#endif + +-- method Repo::set_cache_dir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "directory fd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "subpath in @dfd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_set_cache_dir" ostree_repo_set_cache_dir :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set a custom location for the cache directory used for e.g. +per-remote summary caches. Setting this manually is useful when +doing operations on a system repo as a user because you don\'t have +write permissions in the repo, where the cache is normally stored. +-} +repoSetCacheDir :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Int32 + {- ^ /@dfd@/: directory fd -} + -> T.Text + {- ^ /@path@/: subpath in /@dfd@/ -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSetCacheDir self dfd path cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_set_cache_dir self' dfd path' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data RepoSetCacheDirMethodInfo +instance (signature ~ (Int32 -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSetCacheDirMethodInfo a signature where + overloadedMethod _ = repoSetCacheDir + +#endif + +-- method Repo::set_collection_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new collection ID, or %NULL to unset it", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_set_collection_id" ostree_repo_set_collection_id :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- collection_id : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set or clear the collection ID of this repository. See [collection IDs][collection-ids]. +The update will be made in memory, but must be written out to the repository +configuration on disk using 'GI.OSTree.Objects.Repo.repoWriteConfig'. + +/Since: 2018.6/ +-} +repoSetCollectionId :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (T.Text) + {- ^ /@collectionId@/: new collection ID, or 'Nothing' to unset it -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSetCollectionId self collectionId = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCollectionId <- case collectionId of + Nothing -> return nullPtr + Just jCollectionId -> do + jCollectionId' <- textToCString jCollectionId + return jCollectionId' + onException (do + _ <- propagateGError $ ostree_repo_set_collection_id self' maybeCollectionId + touchManagedPtr self + freeMem maybeCollectionId + return () + ) (do + freeMem maybeCollectionId + ) + +#if ENABLE_OVERLOADING +data RepoSetCollectionIdMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoSetCollectionIdMethodInfo a signature where + overloadedMethod _ = repoSetCollectionId + +#endif + +-- method Repo::set_collection_ref_immediate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TInterface (Name {namespace = "OSTree", name = "CollectionRef"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The collection\8211ref to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The checksum to point it to, or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_set_collection_ref_immediate" ostree_repo_set_collection_ref_immediate :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This is like 'GI.OSTree.Objects.Repo.repoTransactionSetCollectionRef', except it may be +invoked outside of a transaction. This is presently safe for the +case where we\'re creating or overwriting an existing ref. + +/Since: 2018.6/ +-} +repoSetCollectionRefImmediate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> OSTree.CollectionRef.CollectionRef + {- ^ /@ref@/: The collection–ref to write -} + -> Maybe (T.Text) + {- ^ /@checksum@/: The checksum to point it to, or 'Nothing' to unset -} + -> Maybe (b) + {- ^ /@cancellable@/: GCancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSetCollectionRefImmediate self ref checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ref' <- unsafeManagedPtrGetPtr ref + maybeChecksum <- case checksum of + Nothing -> return nullPtr + Just jChecksum -> do + jChecksum' <- textToCString jChecksum + return jChecksum' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_set_collection_ref_immediate self' ref' maybeChecksum maybeCancellable + touchManagedPtr self + touchManagedPtr ref + whenJust cancellable touchManagedPtr + freeMem maybeChecksum + return () + ) (do + freeMem maybeChecksum + ) + +#if ENABLE_OVERLOADING +data RepoSetCollectionRefImmediateMethodInfo +instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSetCollectionRefImmediateMethodInfo a signature where + overloadedMethod _ = repoSetCollectionRefImmediate + +#endif + +-- method Repo::set_disable_fsync +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disable_fsync", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, do not fsync", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_set_disable_fsync" ostree_repo_set_disable_fsync :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CInt -> -- disable_fsync : TBasicType TBoolean + IO () + +{- | +Disable requests to @/fsync()/@ to stable storage during commits. This +option should only be used by build system tools which are creating +disposable virtual machines, or have higher level mechanisms for +ensuring data consistency. +-} +repoSetDisableFsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Bool + {- ^ /@disableFsync@/: If 'True', do not fsync -} + -> m () +repoSetDisableFsync self disableFsync = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let disableFsync' = (fromIntegral . fromEnum) disableFsync + ostree_repo_set_disable_fsync self' disableFsync' + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data RepoSetDisableFsyncMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoSetDisableFsyncMethodInfo a signature where + overloadedMethod _ = repoSetDisableFsync + +#endif + +-- method Repo::set_ref_immediate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A remote for the ref", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The ref to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The checksum to point it to, or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_set_ref_immediate" ostree_repo_set_ref_immediate :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote : TBasicType TUTF8 + CString -> -- ref : TBasicType TUTF8 + CString -> -- checksum : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This is like 'GI.OSTree.Objects.Repo.repoTransactionSetRef', except it may be +invoked outside of a transaction. This is presently safe for the +case where we\'re creating or overwriting an existing ref. + +Multithreading: This function is MT safe. +-} +repoSetRefImmediate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (T.Text) + {- ^ /@remote@/: A remote for the ref -} + -> T.Text + {- ^ /@ref@/: The ref to write -} + -> Maybe (T.Text) + {- ^ /@checksum@/: The checksum to point it to, or 'Nothing' to unset -} + -> Maybe (b) + {- ^ /@cancellable@/: GCancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSetRefImmediate self remote ref checksum cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeRemote <- case remote of + Nothing -> return nullPtr + Just jRemote -> do + jRemote' <- textToCString jRemote + return jRemote' + ref' <- textToCString ref + maybeChecksum <- case checksum of + Nothing -> return nullPtr + Just jChecksum -> do + jChecksum' <- textToCString jChecksum + return jChecksum' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_set_ref_immediate self' maybeRemote ref' maybeChecksum maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem maybeRemote + freeMem ref' + freeMem maybeChecksum + return () + ) (do + freeMem maybeRemote + freeMem ref' + freeMem maybeChecksum + ) + +#if ENABLE_OVERLOADING +data RepoSetRefImmediateMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSetRefImmediateMethodInfo a signature where + overloadedMethod _ = repoSetRefImmediate + +#endif + +-- method Repo::sign_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "SHA256 of given commit to sign", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Use this GPG key id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "homedir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GPG home directory, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_sign_commit" ostree_repo_sign_commit :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit_checksum : TBasicType TUTF8 + CString -> -- key_id : TBasicType TUTF8 + CString -> -- homedir : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a GPG signature to a commit. +-} +repoSignCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@commitChecksum@/: SHA256 of given commit to sign -} + -> T.Text + {- ^ /@keyId@/: Use this GPG key id -} + -> Maybe (T.Text) + {- ^ /@homedir@/: GPG home directory, or 'Nothing' -} + -> Maybe (b) + {- ^ /@cancellable@/: A 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSignCommit self commitChecksum keyId homedir cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + commitChecksum' <- textToCString commitChecksum + keyId' <- textToCString keyId + maybeHomedir <- case homedir of + Nothing -> return nullPtr + Just jHomedir -> do + jHomedir' <- textToCString jHomedir + return jHomedir' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_sign_commit self' commitChecksum' keyId' maybeHomedir maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem commitChecksum' + freeMem keyId' + freeMem maybeHomedir + return () + ) (do + freeMem commitChecksum' + freeMem keyId' + freeMem maybeHomedir + ) + +#if ENABLE_OVERLOADING +data RepoSignCommitMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSignCommitMethodInfo a signature where + overloadedMethod _ = repoSignCommit + +#endif + +-- method Repo::sign_delta +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from_commit", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "From commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_commit", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "To commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "key id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "homedir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "homedir", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_sign_delta" ostree_repo_sign_delta :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- from_commit : TBasicType TUTF8 + CString -> -- to_commit : TBasicType TUTF8 + CString -> -- key_id : TBasicType TUTF8 + CString -> -- homedir : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +This function is deprecated, sign the summary file instead. +Add a GPG signature to a static delta. +-} +repoSignDelta :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@fromCommit@/: From commit -} + -> T.Text + {- ^ /@toCommit@/: To commit -} + -> T.Text + {- ^ /@keyId@/: key id -} + -> T.Text + {- ^ /@homedir@/: homedir -} + -> Maybe (b) + {- ^ /@cancellable@/: cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoSignDelta self fromCommit toCommit keyId homedir cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + fromCommit' <- textToCString fromCommit + toCommit' <- textToCString toCommit + keyId' <- textToCString keyId + homedir' <- textToCString homedir + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_sign_delta self' fromCommit' toCommit' keyId' homedir' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem fromCommit' + freeMem toCommit' + freeMem keyId' + freeMem homedir' + return () + ) (do + freeMem fromCommit' + freeMem toCommit' + freeMem keyId' + freeMem homedir' + ) + +#if ENABLE_OVERLOADING +data RepoSignDeltaMethodInfo +instance (signature ~ (T.Text -> T.Text -> T.Text -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoSignDeltaMethodInfo a signature where + overloadedMethod _ = repoSignDelta + +#endif + +-- method Repo::static_delta_execute_offline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir_or_file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to a directory containing static delta data, or directly to the superblock", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip_validation", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, assume data integrity", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_static_delta_execute_offline" ostree_repo_static_delta_execute_offline :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.File.File -> -- dir_or_file : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- skip_validation : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Given a directory representing an already-downloaded static delta +on disk, apply it, generating a new commit. The directory must be +named with the form \"FROM-TO\", where both are checksums, and it +must contain a file named \"superblock\", along with at least one part. +-} +repoStaticDeltaExecuteOffline :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> b + {- ^ /@dirOrFile@/: Path to a directory containing static delta data, or directly to the superblock -} + -> Bool + {- ^ /@skipValidation@/: If 'True', assume data integrity -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoStaticDeltaExecuteOffline self dirOrFile skipValidation cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + dirOrFile' <- unsafeManagedPtrCastPtr dirOrFile + let skipValidation' = (fromIntegral . fromEnum) skipValidation + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_static_delta_execute_offline self' dirOrFile' skipValidation' maybeCancellable + touchManagedPtr self + touchManagedPtr dirOrFile + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoStaticDeltaExecuteOfflineMethodInfo +instance (signature ~ (b -> Bool -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoStaticDeltaExecuteOfflineMethodInfo a signature where + overloadedMethod _ = repoStaticDeltaExecuteOffline + +#endif + +-- method Repo::static_delta_generate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opt", argType = TInterface (Name {namespace = "OSTree", name = "StaticDeltaGenerateOpt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "High level optimization choice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum of origin, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum of target", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Parameters, see below", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_static_delta_generate" ostree_repo_static_delta_generate :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- opt : TInterface (Name {namespace = "OSTree", name = "StaticDeltaGenerateOpt"}) + CString -> -- from : TBasicType TUTF8 + CString -> -- to : TBasicType TUTF8 + Ptr GVariant -> -- metadata : TVariant + Ptr GVariant -> -- params : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Generate a lookaside \"static delta\" from /@from@/ ('Nothing' means +from-empty) which can generate the objects in /@to@/. This delta is +an optimization over fetching individual objects, and can be +conveniently stored and applied offline. + +The /@params@/ argument should be an a{sv}. The following attributes +are known: + - min-fallback-size: u: Minimum uncompressed size in megabytes to use fallback, 0 to disable fallbacks + - max-chunk-size: u: Maximum size in megabytes of a delta part + - max-bsdiff-size: u: Maximum size in megabytes to consider bsdiff compression + for input files + - compression: y: Compression type: 0=none, x=lzma, g=gzip + - bsdiff-enabled: b: Enable bsdiff compression. Default TRUE. + - inline-parts: b: Put part data in header, to get a single file delta. Default FALSE. + - verbose: b: Print diagnostic messages. Default FALSE. + - endianness: b: Deltas use host byte order by default; this option allows choosing (G_BIG_ENDIAN or G_LITTLE_ENDIAN) + - filename: ay: Save delta superblock to this filename, and parts in the same directory. Default saves to repository. +-} +repoStaticDeltaGenerate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.StaticDeltaGenerateOpt + {- ^ /@opt@/: High level optimization choice -} + -> T.Text + {- ^ /@from@/: ASCII SHA256 checksum of origin, or 'Nothing' -} + -> T.Text + {- ^ /@to@/: ASCII SHA256 checksum of target -} + -> Maybe (GVariant) + {- ^ /@metadata@/: Optional metadata -} + -> Maybe (GVariant) + {- ^ /@params@/: Parameters, see below -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoStaticDeltaGenerate self opt from to metadata params cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let opt' = (fromIntegral . fromEnum) opt + from' <- textToCString from + to' <- textToCString to + maybeMetadata <- case metadata of + Nothing -> return nullPtr + Just jMetadata -> do + jMetadata' <- unsafeManagedPtrGetPtr jMetadata + return jMetadata' + maybeParams <- case params of + Nothing -> return nullPtr + Just jParams -> do + jParams' <- unsafeManagedPtrGetPtr jParams + return jParams' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_static_delta_generate self' opt' from' to' maybeMetadata maybeParams maybeCancellable + touchManagedPtr self + whenJust metadata touchManagedPtr + whenJust params touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem from' + freeMem to' + return () + ) (do + freeMem from' + freeMem to' + ) + +#if ENABLE_OVERLOADING +data RepoStaticDeltaGenerateMethodInfo +instance (signature ~ (OSTree.Enums.StaticDeltaGenerateOpt -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoStaticDeltaGenerateMethodInfo a signature where + overloadedMethod _ = repoStaticDeltaGenerate + +#endif + +-- method Repo::transaction_set_collection_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TInterface (Name {namespace = "OSTree", name = "CollectionRef"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The collection\8211ref to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The checksum to point it to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_transaction_set_collection_ref" ostree_repo_transaction_set_collection_ref :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) + CString -> -- checksum : TBasicType TUTF8 + IO () + +{- | +If /@checksum@/ is not 'Nothing', then record it as the target of local ref named +/@ref@/. + +Otherwise, if /@checksum@/ is 'Nothing', then record that the ref should +be deleted. + +The change will not be written out immediately, but when the transaction +is completed with 'GI.OSTree.Objects.Repo.repoCommitTransaction'. If the transaction +is instead aborted with 'GI.OSTree.Objects.Repo.repoAbortTransaction', no changes will +be made to the repository. + +Multithreading: Since v2017.15 this function is MT safe. + +/Since: 2018.6/ +-} +repoTransactionSetCollectionRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> OSTree.CollectionRef.CollectionRef + {- ^ /@ref@/: The collection–ref to write -} + -> Maybe (T.Text) + {- ^ /@checksum@/: The checksum to point it to -} + -> m () +repoTransactionSetCollectionRef self ref checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ref' <- unsafeManagedPtrGetPtr ref + maybeChecksum <- case checksum of + Nothing -> return nullPtr + Just jChecksum -> do + jChecksum' <- textToCString jChecksum + return jChecksum' + ostree_repo_transaction_set_collection_ref self' ref' maybeChecksum + touchManagedPtr self + touchManagedPtr ref + freeMem maybeChecksum + return () + +#if ENABLE_OVERLOADING +data RepoTransactionSetCollectionRefMethodInfo +instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoTransactionSetCollectionRefMethodInfo a signature where + overloadedMethod _ = repoTransactionSetCollectionRef + +#endif + +-- method Repo::transaction_set_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A remote for the ref", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The ref to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The checksum to point it to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_transaction_set_ref" ostree_repo_transaction_set_ref :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote : TBasicType TUTF8 + CString -> -- ref : TBasicType TUTF8 + CString -> -- checksum : TBasicType TUTF8 + IO () + +{- | +If /@checksum@/ is not 'Nothing', then record it as the target of ref named +/@ref@/; if /@remote@/ is provided, the ref will appear to originate from that +remote. + +Otherwise, if /@checksum@/ is 'Nothing', then record that the ref should +be deleted. + +The change will be written when the transaction is completed with +'GI.OSTree.Objects.Repo.repoCommitTransaction'; that function takes care of writing all of +the objects (such as the commit referred to by /@checksum@/) before updating the +refs. If the transaction is instead aborted with +'GI.OSTree.Objects.Repo.repoAbortTransaction', no changes to the ref will be made to the +repository. + +Note however that currently writing *multiple* refs is not truly atomic; if +the process or system is terminated during +'GI.OSTree.Objects.Repo.repoCommitTransaction', it is possible that just some of the refs +will have been updated. Your application should take care to handle this +case. + +Multithreading: Since v2017.15 this function is MT safe. +-} +repoTransactionSetRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> Maybe (T.Text) + {- ^ /@remote@/: A remote for the ref -} + -> T.Text + {- ^ /@ref@/: The ref to write -} + -> Maybe (T.Text) + {- ^ /@checksum@/: The checksum to point it to -} + -> m () +repoTransactionSetRef self remote ref checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeRemote <- case remote of + Nothing -> return nullPtr + Just jRemote -> do + jRemote' <- textToCString jRemote + return jRemote' + ref' <- textToCString ref + maybeChecksum <- case checksum of + Nothing -> return nullPtr + Just jChecksum -> do + jChecksum' <- textToCString jChecksum + return jChecksum' + ostree_repo_transaction_set_ref self' maybeRemote ref' maybeChecksum + touchManagedPtr self + freeMem maybeRemote + freeMem ref' + freeMem maybeChecksum + return () + +#if ENABLE_OVERLOADING +data RepoTransactionSetRefMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoTransactionSetRefMethodInfo a signature where + overloadedMethod _ = repoTransactionSetRef + +#endif + +-- method Repo::transaction_set_refspec +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The refspec to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The checksum to point it to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_transaction_set_refspec" ostree_repo_transaction_set_refspec :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- refspec : TBasicType TUTF8 + CString -> -- checksum : TBasicType TUTF8 + IO () + +{- | +Like 'GI.OSTree.Objects.Repo.repoTransactionSetRef', but takes concatenated +/@refspec@/ format as input instead of separate remote and name +arguments. + +Multithreading: Since v2017.15 this function is MT safe. +-} +repoTransactionSetRefspec :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> T.Text + {- ^ /@refspec@/: The refspec to write -} + -> Maybe (T.Text) + {- ^ /@checksum@/: The checksum to point it to -} + -> m () +repoTransactionSetRefspec self refspec checksum = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refspec' <- textToCString refspec + maybeChecksum <- case checksum of + Nothing -> return nullPtr + Just jChecksum -> do + jChecksum' <- textToCString jChecksum + return jChecksum' + ostree_repo_transaction_set_refspec self' refspec' maybeChecksum + touchManagedPtr self + freeMem refspec' + freeMem maybeChecksum + return () + +#if ENABLE_OVERLOADING +data RepoTransactionSetRefspecMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoTransactionSetRefspecMethodInfo a signature where + overloadedMethod _ = repoTransactionSetRefspec + +#endif + +-- XXX Could not generate method Repo::traverse_commit +-- Error was : Not implemented: "GHashTable element of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoTraverseCommitMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "traverseCommit" Repo) => O.MethodInfo RepoTraverseCommitMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::traverse_reachable_refs +-- Error was : Not implemented: "GHashTable key of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoTraverseReachableRefsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "traverseReachableRefs" Repo) => O.MethodInfo RepoTraverseReachableRefsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method Repo::verify_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyringdir", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to directory GPG keyrings; overrides built-in default if given", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extra_keyring", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to additional keyring file (not a directory)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_verify_commit" ostree_repo_verify_commit :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit_checksum : TBasicType TUTF8 + Ptr Gio.File.File -> -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check for a valid GPG signature on commit named by the ASCII +checksum /@commitChecksum@/. +-} +repoVerifyCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: Repository -} + -> T.Text + {- ^ /@commitChecksum@/: ASCII SHA256 checksum -} + -> Maybe (b) + {- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given -} + -> Maybe (c) + {- ^ /@extraKeyring@/: Path to additional keyring file (not a directory) -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoVerifyCommit self commitChecksum keyringdir extraKeyring cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + commitChecksum' <- textToCString commitChecksum + maybeKeyringdir <- case keyringdir of + Nothing -> return nullPtr + Just jKeyringdir -> do + jKeyringdir' <- unsafeManagedPtrCastPtr jKeyringdir + return jKeyringdir' + maybeExtraKeyring <- case extraKeyring of + Nothing -> return nullPtr + Just jExtraKeyring -> do + jExtraKeyring' <- unsafeManagedPtrCastPtr jExtraKeyring + return jExtraKeyring' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_verify_commit self' commitChecksum' maybeKeyringdir maybeExtraKeyring maybeCancellable + touchManagedPtr self + whenJust keyringdir touchManagedPtr + whenJust extraKeyring touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem commitChecksum' + return () + ) (do + freeMem commitChecksum' + ) + +#if ENABLE_OVERLOADING +data RepoVerifyCommitMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.MethodInfo RepoVerifyCommitMethodInfo a signature where + overloadedMethod _ = repoVerifyCommit + +#endif + +-- method Repo::verify_commit_ext +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyringdir", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to directory GPG keyrings; overrides built-in default if given", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extra_keyring", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to additional keyring file (not a directory)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_verify_commit_ext" ostree_repo_verify_commit_ext :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit_checksum : TBasicType TUTF8 + Ptr Gio.File.File -> -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.File.File -> -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult) + +{- | +Read GPG signature(s) on the commit named by the ASCII checksum +/@commitChecksum@/ and return detailed results. +-} +repoVerifyCommitExt :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: Repository -} + -> T.Text + {- ^ /@commitChecksum@/: ASCII SHA256 checksum -} + -> Maybe (b) + {- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given -} + -> Maybe (c) + {- ^ /@extraKeyring@/: Path to additional keyring file (not a directory) -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m OSTree.GpgVerifyResult.GpgVerifyResult + {- ^ __Returns:__ an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoVerifyCommitExt self commitChecksum keyringdir extraKeyring cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + commitChecksum' <- textToCString commitChecksum + maybeKeyringdir <- case keyringdir of + Nothing -> return nullPtr + Just jKeyringdir -> do + jKeyringdir' <- unsafeManagedPtrCastPtr jKeyringdir + return jKeyringdir' + maybeExtraKeyring <- case extraKeyring of + Nothing -> return nullPtr + Just jExtraKeyring -> do + jExtraKeyring' <- unsafeManagedPtrCastPtr jExtraKeyring + return jExtraKeyring' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_verify_commit_ext self' commitChecksum' maybeKeyringdir maybeExtraKeyring maybeCancellable + checkUnexpectedReturnNULL "repoVerifyCommitExt" result + result' <- (wrapObject OSTree.GpgVerifyResult.GpgVerifyResult) result + touchManagedPtr self + whenJust keyringdir touchManagedPtr + whenJust extraKeyring touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem commitChecksum' + return result' + ) (do + freeMem commitChecksum' + ) + +#if ENABLE_OVERLOADING +data RepoVerifyCommitExtMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.MethodInfo RepoVerifyCommitExtMethodInfo a signature where + overloadedMethod _ = repoVerifyCommitExt + +#endif + +-- method Repo::verify_commit_for_remote +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "OSTree remote to use for configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_verify_commit_for_remote" ostree_repo_verify_commit_for_remote :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- commit_checksum : TBasicType TUTF8 + CString -> -- remote_name : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult) + +{- | +Read GPG signature(s) on the commit named by the ASCII checksum +/@commitChecksum@/ and return detailed results, based on the keyring +configured for /@remote@/. +-} +repoVerifyCommitForRemote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repository -} + -> T.Text + {- ^ /@commitChecksum@/: ASCII SHA256 checksum -} + -> T.Text + {- ^ /@remoteName@/: OSTree remote to use for configuration -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m OSTree.GpgVerifyResult.GpgVerifyResult + {- ^ __Returns:__ an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoVerifyCommitForRemote self commitChecksum remoteName cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + commitChecksum' <- textToCString commitChecksum + remoteName' <- textToCString remoteName + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_verify_commit_for_remote self' commitChecksum' remoteName' maybeCancellable + checkUnexpectedReturnNULL "repoVerifyCommitForRemote" result + result' <- (wrapObject OSTree.GpgVerifyResult.GpgVerifyResult) result + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem commitChecksum' + freeMem remoteName' + return result' + ) (do + freeMem commitChecksum' + freeMem remoteName' + ) + +#if ENABLE_OVERLOADING +data RepoVerifyCommitForRemoteMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (b) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoVerifyCommitForRemoteMethodInfo a signature where + overloadedMethod _ = repoVerifyCommitForRemote + +#endif + +-- method Repo::verify_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of remote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "summary", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Summary data as a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signatures", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Summary signatures as a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "GpgVerifyResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_verify_summary" ostree_repo_verify_summary :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- remote_name : TBasicType TUTF8 + Ptr GLib.Bytes.Bytes -> -- summary : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr GLib.Bytes.Bytes -> -- signatures : TInterface (Name {namespace = "GLib", name = "Bytes"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult) + +{- | +Verify /@signatures@/ for /@summary@/ data using GPG keys in the keyring for +/@remoteName@/, and return an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'. +-} +repoVerifySummary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@remoteName@/: Name of remote -} + -> GLib.Bytes.Bytes + {- ^ /@summary@/: Summary data as a 'GI.GLib.Structs.Bytes.Bytes' -} + -> GLib.Bytes.Bytes + {- ^ /@signatures@/: Summary signatures as a 'GI.GLib.Structs.Bytes.Bytes' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m OSTree.GpgVerifyResult.GpgVerifyResult + {- ^ __Returns:__ an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoVerifySummary self remoteName summary signatures cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + remoteName' <- textToCString remoteName + summary' <- unsafeManagedPtrGetPtr summary + signatures' <- unsafeManagedPtrGetPtr signatures + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_verify_summary self' remoteName' summary' signatures' maybeCancellable + checkUnexpectedReturnNULL "repoVerifySummary" result + result' <- (wrapObject OSTree.GpgVerifyResult.GpgVerifyResult) result + touchManagedPtr self + touchManagedPtr summary + touchManagedPtr signatures + whenJust cancellable touchManagedPtr + freeMem remoteName' + return result' + ) (do + freeMem remoteName' + ) + +#if ENABLE_OVERLOADING +data RepoVerifySummaryMethodInfo +instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> Maybe (b) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoVerifySummaryMethodInfo a signature where + overloadedMethod _ = repoVerifySummary + +#endif + +-- method Repo::write_archive_to_mtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "archive", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A path to an archive file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mtree", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #OstreeMutableTree to write to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional commit modifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "autocreate_parents", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Autocreate parent directories", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_archive_to_mtree" ostree_repo_write_archive_to_mtree :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.File.File -> -- archive : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr OSTree.MutableTree.MutableTree -> -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + CInt -> -- autocreate_parents : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Import an archive file /@archive@/ into the repository, and write its +file structure to /@mtree@/. +-} +repoWriteArchiveToMtree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: An 'GI.OSTree.Objects.Repo.Repo' -} + -> b + {- ^ /@archive@/: A path to an archive file -} + -> c + {- ^ /@mtree@/: The 'GI.OSTree.Objects.MutableTree.MutableTree' to write to -} + -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) + {- ^ /@modifier@/: Optional commit modifier -} + -> Bool + {- ^ /@autocreateParents@/: Autocreate parent directories -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteArchiveToMtree self archive mtree modifier autocreateParents cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + archive' <- unsafeManagedPtrCastPtr archive + mtree' <- unsafeManagedPtrCastPtr mtree + maybeModifier <- case modifier of + Nothing -> return nullPtr + Just jModifier -> do + jModifier' <- unsafeManagedPtrGetPtr jModifier + return jModifier' + let autocreateParents' = (fromIntegral . fromEnum) autocreateParents + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_archive_to_mtree self' archive' mtree' maybeModifier autocreateParents' maybeCancellable + touchManagedPtr self + touchManagedPtr archive + touchManagedPtr mtree + whenJust modifier touchManagedPtr + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoWriteArchiveToMtreeMethodInfo +instance (signature ~ (b -> c -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Bool -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => O.MethodInfo RepoWriteArchiveToMtreeMethodInfo a signature where + overloadedMethod _ = repoWriteArchiveToMtree + +#endif + +-- method Repo::write_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum for parent, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subject", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Subject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Body", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GVariant of type a{sv}, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "root", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The tree to point the commit to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_commit", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Resulting ASCII SHA256 checksum for commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_commit" ostree_repo_write_commit :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- parent : TBasicType TUTF8 + CString -> -- subject : TBasicType TUTF8 + CString -> -- body : TBasicType TUTF8 + Ptr GVariant -> -- metadata : TVariant + Ptr OSTree.RepoFile.RepoFile -> -- root : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Ptr CString -> -- out_commit : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write a commit metadata object, referencing /@rootContentsChecksum@/ +and /@rootMetadataChecksum@/. +-} +repoWriteCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Maybe (T.Text) + {- ^ /@parent@/: ASCII SHA256 checksum for parent, or 'Nothing' for none -} + -> Maybe (T.Text) + {- ^ /@subject@/: Subject -} + -> Maybe (T.Text) + {- ^ /@body@/: Body -} + -> Maybe (GVariant) + {- ^ /@metadata@/: GVariant of type a{sv}, or 'Nothing' for none -} + -> b + {- ^ /@root@/: The tree to point the commit to -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteCommit self parent subject body metadata root cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeParent <- case parent of + Nothing -> return nullPtr + Just jParent -> do + jParent' <- textToCString jParent + return jParent' + maybeSubject <- case subject of + Nothing -> return nullPtr + Just jSubject -> do + jSubject' <- textToCString jSubject + return jSubject' + maybeBody <- case body of + Nothing -> return nullPtr + Just jBody -> do + jBody' <- textToCString jBody + return jBody' + maybeMetadata <- case metadata of + Nothing -> return nullPtr + Just jMetadata -> do + jMetadata' <- unsafeManagedPtrGetPtr jMetadata + return jMetadata' + root' <- unsafeManagedPtrCastPtr root + outCommit <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_commit self' maybeParent maybeSubject maybeBody maybeMetadata root' outCommit maybeCancellable + outCommit' <- peek outCommit + outCommit'' <- cstringToText outCommit' + freeMem outCommit' + touchManagedPtr self + whenJust metadata touchManagedPtr + touchManagedPtr root + whenJust cancellable touchManagedPtr + freeMem maybeParent + freeMem maybeSubject + freeMem maybeBody + freeMem outCommit + return outCommit'' + ) (do + freeMem maybeParent + freeMem maybeSubject + freeMem maybeBody + freeMem outCommit + ) + +#if ENABLE_OVERLOADING +data RepoWriteCommitMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (GVariant) -> b -> Maybe (c) -> m (T.Text)), MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteCommitMethodInfo a signature where + overloadedMethod _ = repoWriteCommit + +#endif + +-- method Repo::write_commit_detached_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ASCII SHA256 commit checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Metadata to associate with commit in with format \"a{sv}\", or %NULL to delete", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_commit_detached_metadata" ostree_repo_write_commit_detached_metadata :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr GVariant -> -- metadata : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Replace any existing metadata associated with commit referred to by +/@checksum@/ with /@metadata@/. If /@metadata@/ is 'Nothing', then existing +data will be deleted. +-} +repoWriteCommitDetachedMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: ASCII SHA256 commit checksum -} + -> Maybe (GVariant) + {- ^ /@metadata@/: Metadata to associate with commit in with format \"a{sv}\", or 'Nothing' to delete -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteCommitDetachedMetadata self checksum metadata cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + maybeMetadata <- case metadata of + Nothing -> return nullPtr + Just jMetadata -> do + jMetadata' <- unsafeManagedPtrGetPtr jMetadata + return jMetadata' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_commit_detached_metadata self' checksum' maybeMetadata maybeCancellable + touchManagedPtr self + whenJust metadata touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoWriteCommitDetachedMetadataMethodInfo +instance (signature ~ (T.Text -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoWriteCommitDetachedMetadataMethodInfo a signature where + overloadedMethod _ = repoWriteCommitDetachedMetadata + +#endif + +-- method Repo::write_commit_with_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "ASCII SHA256 checksum for parent, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subject", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Subject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Body", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "GVariant of type a{sv}, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "root", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The tree to point the commit to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The time to use to stamp the commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_commit", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Resulting ASCII SHA256 checksum for commit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_commit_with_time" ostree_repo_write_commit_with_time :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- parent : TBasicType TUTF8 + CString -> -- subject : TBasicType TUTF8 + CString -> -- body : TBasicType TUTF8 + Ptr GVariant -> -- metadata : TVariant + Ptr OSTree.RepoFile.RepoFile -> -- root : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Word64 -> -- time : TBasicType TUInt64 + Ptr CString -> -- out_commit : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write a commit metadata object, referencing /@rootContentsChecksum@/ +and /@rootMetadataChecksum@/. +-} +repoWriteCommitWithTime :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Maybe (T.Text) + {- ^ /@parent@/: ASCII SHA256 checksum for parent, or 'Nothing' for none -} + -> Maybe (T.Text) + {- ^ /@subject@/: Subject -} + -> Maybe (T.Text) + {- ^ /@body@/: Body -} + -> Maybe (GVariant) + {- ^ /@metadata@/: GVariant of type a{sv}, or 'Nothing' for none -} + -> b + {- ^ /@root@/: The tree to point the commit to -} + -> Word64 + {- ^ /@time@/: The time to use to stamp the commit -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteCommitWithTime self parent subject body metadata root time cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeParent <- case parent of + Nothing -> return nullPtr + Just jParent -> do + jParent' <- textToCString jParent + return jParent' + maybeSubject <- case subject of + Nothing -> return nullPtr + Just jSubject -> do + jSubject' <- textToCString jSubject + return jSubject' + maybeBody <- case body of + Nothing -> return nullPtr + Just jBody -> do + jBody' <- textToCString jBody + return jBody' + maybeMetadata <- case metadata of + Nothing -> return nullPtr + Just jMetadata -> do + jMetadata' <- unsafeManagedPtrGetPtr jMetadata + return jMetadata' + root' <- unsafeManagedPtrCastPtr root + outCommit <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_commit_with_time self' maybeParent maybeSubject maybeBody maybeMetadata root' time outCommit maybeCancellable + outCommit' <- peek outCommit + outCommit'' <- cstringToText outCommit' + freeMem outCommit' + touchManagedPtr self + whenJust metadata touchManagedPtr + touchManagedPtr root + whenJust cancellable touchManagedPtr + freeMem maybeParent + freeMem maybeSubject + freeMem maybeBody + freeMem outCommit + return outCommit'' + ) (do + freeMem maybeParent + freeMem maybeSubject + freeMem maybeBody + freeMem outCommit + ) + +#if ENABLE_OVERLOADING +data RepoWriteCommitWithTimeMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (GVariant) -> b -> Word64 -> Maybe (c) -> m (T.Text)), MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteCommitWithTimeMethodInfo a signature where + overloadedMethod _ = repoWriteCommitWithTime + +#endif + +-- method Repo::write_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_config", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Overwrite the config file with this data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_config" ostree_repo_write_config :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr GLib.KeyFile.KeyFile -> -- new_config : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Save /@newConfig@/ in place of this repository\'s config file. +-} +repoWriteConfig :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a) => + a + {- ^ /@self@/: Repo -} + -> GLib.KeyFile.KeyFile + {- ^ /@newConfig@/: Overwrite the config file with this data -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteConfig self newConfig = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + newConfig' <- unsafeManagedPtrGetPtr newConfig + onException (do + _ <- propagateGError $ ostree_repo_write_config self' newConfig' + touchManagedPtr self + touchManagedPtr newConfig + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoWriteConfigMethodInfo +instance (signature ~ (GLib.KeyFile.KeyFile -> m ()), MonadIO m, IsRepo a) => O.MethodInfo RepoWriteConfigMethodInfo a signature where + overloadedMethod _ = repoWriteConfig + +#endif + +-- method Repo::write_content +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expected_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "If provided, validate content against this checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Content object stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of @object_input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_content" ostree_repo_write_content :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- expected_checksum : TBasicType TUTF8 + Ptr Gio.InputStream.InputStream -> -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Word64 -> -- length : TBasicType TUInt64 + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store the content object streamed as /@objectInput@/, +with total length /@length@/. The actual checksum will +be returned as /@outCsum@/. +-} +repoWriteContent :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Maybe (T.Text) + {- ^ /@expectedChecksum@/: If provided, validate content against this checksum -} + -> b + {- ^ /@objectInput@/: Content object stream -} + -> Word64 + {- ^ /@length@/: Length of /@objectInput@/ -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteContent self expectedChecksum objectInput length_ cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeExpectedChecksum <- case expectedChecksum of + Nothing -> return nullPtr + Just jExpectedChecksum -> do + jExpectedChecksum' <- textToCString jExpectedChecksum + return jExpectedChecksum' + objectInput' <- unsafeManagedPtrCastPtr objectInput + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_content self' maybeExpectedChecksum objectInput' length_ outCsum maybeCancellable + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr self + touchManagedPtr objectInput + whenJust cancellable touchManagedPtr + freeMem maybeExpectedChecksum + freeMem outCsum + return outCsum'' + ) (do + freeMem maybeExpectedChecksum + freeMem outCsum + ) + +#if ENABLE_OVERLOADING +data RepoWriteContentMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> Word64 -> Maybe (c) -> m (ByteString)), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteContentMethodInfo a signature where + overloadedMethod _ = repoWriteContent + +#endif + +-- method Repo::write_content_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expected_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "If provided, validate content against this checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of @object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Invoked when content is writed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_write_content_async" ostree_repo_write_content_async :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- expected_checksum : TBasicType TUTF8 + Ptr Gio.InputStream.InputStream -> -- object : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Word64 -> -- length : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Asynchronously store the content object /@object@/. If provided, the +checksum /@expectedChecksum@/ will be verified. +-} +repoWriteContentAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Maybe (T.Text) + {- ^ /@expectedChecksum@/: If provided, validate content against this checksum -} + -> b + {- ^ /@object@/: Input -} + -> Word64 + {- ^ /@length@/: Length of /@object@/ -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: Invoked when content is writed -} + -> m () +repoWriteContentAsync self expectedChecksum object length_ cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeExpectedChecksum <- case expectedChecksum of + Nothing -> return nullPtr + Just jExpectedChecksum -> do + jExpectedChecksum' <- textToCString jExpectedChecksum + return jExpectedChecksum' + object' <- unsafeManagedPtrCastPtr object + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_write_content_async self' maybeExpectedChecksum object' length_ maybeCancellable maybeCallback userData + touchManagedPtr self + touchManagedPtr object + whenJust cancellable touchManagedPtr + freeMem maybeExpectedChecksum + return () + +#if ENABLE_OVERLOADING +data RepoWriteContentAsyncMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> Word64 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteContentAsyncMethodInfo a signature where + overloadedMethod _ = repoWriteContentAsync + +#endif + +-- method Repo::write_content_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #OstreeRepo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A binary SHA256 checksum of the content object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_content_finish" ostree_repo_write_content_finish :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr Word8 -> -- out_csum : TBasicType TUInt8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Completes an invocation of 'GI.OSTree.Objects.Repo.repoWriteContentAsync'. +-} +repoWriteContentFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: a 'GI.OSTree.Objects.Repo.Repo' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m (Word8) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteContentFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + outCsum <- allocMem :: IO (Ptr Word8) + onException (do + _ <- propagateGError $ ostree_repo_write_content_finish self' result_' outCsum + outCsum' <- peek outCsum + touchManagedPtr self + touchManagedPtr result_ + freeMem outCsum + return outCsum' + ) (do + freeMem outCsum + ) + +#if ENABLE_OVERLOADING +data RepoWriteContentFinishMethodInfo +instance (signature ~ (b -> m (Word8)), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RepoWriteContentFinishMethodInfo a signature where + overloadedMethod _ = repoWriteContentFinish + +#endif + +-- method Repo::write_content_trusted +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Store content using this ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Content stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of @object_input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_content_trusted" ostree_repo_write_content_trusted :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr Gio.InputStream.InputStream -> -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Word64 -> -- length : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store the content object streamed as /@objectInput@/, with total +length /@length@/. The given /@checksum@/ will be treated as trusted. + +This function should be used when importing file objects from local +disk, for example. +-} +repoWriteContentTrusted :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> T.Text + {- ^ /@checksum@/: Store content using this ASCII SHA256 checksum -} + -> b + {- ^ /@objectInput@/: Content stream -} + -> Word64 + {- ^ /@length@/: Length of /@objectInput@/ -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteContentTrusted self checksum objectInput length_ cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + objectInput' <- unsafeManagedPtrCastPtr objectInput + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_content_trusted self' checksum' objectInput' length_ maybeCancellable + touchManagedPtr self + touchManagedPtr objectInput + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoWriteContentTrustedMethodInfo +instance (signature ~ (T.Text -> b -> Word64 -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteContentTrustedMethodInfo a signature where + overloadedMethod _ = repoWriteContentTrusted + +#endif + +-- method Repo::write_dfd_to_mtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory file descriptor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mtree", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Overlay directory contents into this tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional modifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_dfd_to_mtree" ostree_repo_write_dfd_to_mtree :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr OSTree.MutableTree.MutableTree -> -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store as objects all contents of the directory referred to by /@dfd@/ +and /@path@/ all children into the repository /@self@/, overlaying the +resulting filesystem hierarchy into /@mtree@/. +-} +repoWriteDfdToMtree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> Int32 + {- ^ /@dfd@/: Directory file descriptor -} + -> T.Text + {- ^ /@path@/: Path -} + -> b + {- ^ /@mtree@/: Overlay directory contents into this tree -} + -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) + {- ^ /@modifier@/: Optional modifier -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteDfdToMtree self dfd path mtree modifier cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + mtree' <- unsafeManagedPtrCastPtr mtree + maybeModifier <- case modifier of + Nothing -> return nullPtr + Just jModifier -> do + jModifier' <- unsafeManagedPtrGetPtr jModifier + return jModifier' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_dfd_to_mtree self' dfd path' mtree' maybeModifier maybeCancellable + touchManagedPtr self + touchManagedPtr mtree + whenJust modifier touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data RepoWriteDfdToMtreeMethodInfo +instance (signature ~ (Int32 -> T.Text -> b -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteDfdToMtreeMethodInfo a signature where + overloadedMethod _ = repoWriteDfdToMtree + +#endif + +-- method Repo::write_directory_to_mtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to a directory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mtree", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Overlay directory contents into this tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional modifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_directory_to_mtree" ostree_repo_write_directory_to_mtree :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.File.File -> -- dir : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr OSTree.MutableTree.MutableTree -> -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store objects for /@dir@/ and all children into the repository /@self@/, +overlaying the resulting filesystem hierarchy into /@mtree@/. +-} +repoWriteDirectoryToMtree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: Repo -} + -> b + {- ^ /@dir@/: Path to a directory -} + -> c + {- ^ /@mtree@/: Overlay directory contents into this tree -} + -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) + {- ^ /@modifier@/: Optional modifier -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteDirectoryToMtree self dir mtree modifier cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + dir' <- unsafeManagedPtrCastPtr dir + mtree' <- unsafeManagedPtrCastPtr mtree + maybeModifier <- case modifier of + Nothing -> return nullPtr + Just jModifier -> do + jModifier' <- unsafeManagedPtrGetPtr jModifier + return jModifier' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_directory_to_mtree self' dir' mtree' maybeModifier maybeCancellable + touchManagedPtr self + touchManagedPtr dir + touchManagedPtr mtree + whenJust modifier touchManagedPtr + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoWriteDirectoryToMtreeMethodInfo +instance (signature ~ (b -> c -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => O.MethodInfo RepoWriteDirectoryToMtreeMethodInfo a signature where + overloadedMethod _ = repoWriteDirectoryToMtree + +#endif + +-- method Repo::write_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expected_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "If provided, validate content against this checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Binary checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_metadata" ostree_repo_write_metadata :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- expected_checksum : TBasicType TUTF8 + Ptr GVariant -> -- object : TVariant + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store the metadata object /@object@/. Return the checksum +as /@outCsum@/. + +If /@expectedChecksum@/ is not 'Nothing', verify it against the +computed checksum. +-} +repoWriteMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> Maybe (T.Text) + {- ^ /@expectedChecksum@/: If provided, validate content against this checksum -} + -> GVariant + {- ^ /@object@/: Metadata -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteMetadata self objtype expectedChecksum object cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + maybeExpectedChecksum <- case expectedChecksum of + Nothing -> return nullPtr + Just jExpectedChecksum -> do + jExpectedChecksum' <- textToCString jExpectedChecksum + return jExpectedChecksum' + object' <- unsafeManagedPtrGetPtr object + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_metadata self' objtype' maybeExpectedChecksum object' outCsum maybeCancellable + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr self + touchManagedPtr object + whenJust cancellable touchManagedPtr + freeMem maybeExpectedChecksum + freeMem outCsum + return outCsum'' + ) (do + freeMem maybeExpectedChecksum + freeMem outCsum + ) + +#if ENABLE_OVERLOADING +data RepoWriteMetadataMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> Maybe (T.Text) -> GVariant -> Maybe (b) -> m (ByteString)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoWriteMetadataMethodInfo a signature where + overloadedMethod _ = repoWriteMetadata + +#endif + +-- method Repo::write_metadata_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expected_checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "If provided, validate content against this checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Invoked when metadata is writed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_write_metadata_async" ostree_repo_write_metadata_async :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- expected_checksum : TBasicType TUTF8 + Ptr GVariant -> -- object : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Asynchronously store the metadata object /@variant@/. If provided, +the checksum /@expectedChecksum@/ will be verified. +-} +repoWriteMetadataAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> Maybe (T.Text) + {- ^ /@expectedChecksum@/: If provided, validate content against this checksum -} + -> GVariant + {- ^ /@object@/: Metadata -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: Invoked when metadata is writed -} + -> m () +repoWriteMetadataAsync self objtype expectedChecksum object cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + maybeExpectedChecksum <- case expectedChecksum of + Nothing -> return nullPtr + Just jExpectedChecksum -> do + jExpectedChecksum' <- textToCString jExpectedChecksum + return jExpectedChecksum' + object' <- unsafeManagedPtrGetPtr object + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_repo_write_metadata_async self' objtype' maybeExpectedChecksum object' maybeCancellable maybeCallback userData + touchManagedPtr self + touchManagedPtr object + whenJust cancellable touchManagedPtr + freeMem maybeExpectedChecksum + return () + +#if ENABLE_OVERLOADING +data RepoWriteMetadataAsyncMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> Maybe (T.Text) -> GVariant -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoWriteMetadataAsyncMethodInfo a signature where + overloadedMethod _ = repoWriteMetadataAsync + +#endif + +-- method Repo::write_metadata_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_csum", argType = TCArray False 32 (-1) (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Binary checksum value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_metadata_finish" ostree_repo_write_metadata_finish :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr Word8) -> -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Complete a call to 'GI.OSTree.Objects.Repo.repoWriteMetadataAsync'. +-} +repoWriteMetadataFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: Repo -} + -> b + {- ^ /@result@/: Result -} + -> m (ByteString) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteMetadataFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + outCsum <- allocMem :: IO (Ptr (Ptr Word8)) + onException (do + _ <- propagateGError $ ostree_repo_write_metadata_finish self' result_' outCsum + outCsum' <- peek outCsum + outCsum'' <- (unpackByteStringWithLength 32) outCsum' + freeMem outCsum' + touchManagedPtr self + touchManagedPtr result_ + freeMem outCsum + return outCsum'' + ) (do + freeMem outCsum + ) + +#if ENABLE_OVERLOADING +data RepoWriteMetadataFinishMethodInfo +instance (signature ~ (b -> m (ByteString)), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RepoWriteMetadataFinishMethodInfo a signature where + overloadedMethod _ = repoWriteMetadataFinish + +#endif + +-- method Repo::write_metadata_stream_trusted +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Store object with this ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_input", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata object stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length, may be 0 for unknown", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_metadata_stream_trusted" ostree_repo_write_metadata_stream_trusted :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr Gio.InputStream.InputStream -> -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Word64 -> -- length : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store the metadata object /@variant@/; the provided /@checksum@/ is +trusted. +-} +repoWriteMetadataStreamTrusted :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: Store object with this ASCII SHA256 checksum -} + -> b + {- ^ /@objectInput@/: Metadata object stream -} + -> Word64 + {- ^ /@length@/: Length, may be 0 for unknown -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteMetadataStreamTrusted self objtype checksum objectInput length_ cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + objectInput' <- unsafeManagedPtrCastPtr objectInput + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_metadata_stream_trusted self' objtype' checksum' objectInput' length_ maybeCancellable + touchManagedPtr self + touchManagedPtr objectInput + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoWriteMetadataStreamTrustedMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> b -> Word64 -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteMetadataStreamTrustedMethodInfo a signature where + overloadedMethod _ = repoWriteMetadataStreamTrusted + +#endif + +-- method Repo::write_metadata_trusted +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "objtype", argType = TInterface (Name {namespace = "OSTree", name = "ObjectType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Object type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Store object with this ASCII SHA256 checksum", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Metadata object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_metadata_trusted" ostree_repo_write_metadata_trusted :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CUInt -> -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr GVariant -> -- variant : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store the metadata object /@variant@/; the provided /@checksum@/ is +trusted. +-} +repoWriteMetadataTrusted :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Repo -} + -> OSTree.Enums.ObjectType + {- ^ /@objtype@/: Object type -} + -> T.Text + {- ^ /@checksum@/: Store object with this ASCII SHA256 checksum -} + -> GVariant + {- ^ /@variant@/: Metadata object -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteMetadataTrusted self objtype checksum variant cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objtype' = (fromIntegral . fromEnum) objtype + checksum' <- textToCString checksum + variant' <- unsafeManagedPtrGetPtr variant + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_metadata_trusted self' objtype' checksum' variant' maybeCancellable + touchManagedPtr self + touchManagedPtr variant + whenJust cancellable touchManagedPtr + freeMem checksum' + return () + ) (do + freeMem checksum' + ) + +#if ENABLE_OVERLOADING +data RepoWriteMetadataTrustedMethodInfo +instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> GVariant -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoWriteMetadataTrustedMethodInfo a signature where + overloadedMethod _ = repoWriteMetadataTrusted + +#endif + +-- method Repo::write_mtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mtree", argType = TInterface (Name {namespace = "OSTree", name = "MutableTree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Mutable tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepoFile representing @mtree's root.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_write_mtree" ostree_repo_write_mtree :: + Ptr Repo -> -- self : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr OSTree.MutableTree.MutableTree -> -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"}) + Ptr (Ptr Gio.File.File) -> -- out_file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write all metadata objects for /@mtree@/ to repo; the resulting +/@outFile@/ points to the 'GI.OSTree.Enums.ObjectTypeDirTree' object that +the /@mtree@/ represented. +-} +repoWriteMtree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Repo -} + -> b + {- ^ /@mtree@/: Mutable tree -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (Gio.File.File) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoWriteMtree self mtree cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + mtree' <- unsafeManagedPtrCastPtr mtree + outFile <- allocMem :: IO (Ptr (Ptr Gio.File.File)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_write_mtree self' mtree' outFile maybeCancellable + outFile' <- peek outFile + outFile'' <- (wrapObject Gio.File.File) outFile' + touchManagedPtr self + touchManagedPtr mtree + whenJust cancellable touchManagedPtr + freeMem outFile + return outFile'' + ) (do + freeMem outFile + ) + +#if ENABLE_OVERLOADING +data RepoWriteMtreeMethodInfo +instance (signature ~ (b -> Maybe (c) -> m (Gio.File.File)), MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoWriteMtreeMethodInfo a signature where + overloadedMethod _ = repoWriteMtree + +#endif + +-- method Repo::create_at +-- method type : MemberFunction +-- Args : [Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory fd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "OSTree", name = "RepoMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The mode to store the repository in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a{sv}: See below for accepted keys", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_create_at" ostree_repo_create_at :: + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + CUInt -> -- mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"}) + Ptr GVariant -> -- options : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Repo) + +{- | +This is a file-descriptor relative version of 'GI.OSTree.Objects.Repo.repoCreate'. +Create the underlying structure on disk for the repository, and call +'GI.OSTree.Objects.Repo.repoOpenAt' on the result, preparing it for use. + +If a repository already exists at /@dfd@/ + /@path@/ (defined by an @objects\/@ +subdirectory existing), then this function will simply call +'GI.OSTree.Objects.Repo.repoOpenAt'. In other words, this function cannot be used to change +the mode or configuration (@repo\/config@) of an existing repo. + +The /@options@/ dict may contain: + + - collection-id: s: Set as collection ID in repo\/config (Since 2017.9) +-} +repoCreateAt :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Int32 + {- ^ /@dfd@/: Directory fd -} + -> T.Text + {- ^ /@path@/: Path -} + -> OSTree.Enums.RepoMode + {- ^ /@mode@/: The mode to store the repository in -} + -> GVariant + {- ^ /@options@/: a{sv}: See below for accepted keys -} + -> Maybe (a) + {- ^ /@cancellable@/: Cancellable -} + -> m Repo + {- ^ __Returns:__ A new OSTree repository reference /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCreateAt dfd path mode options cancellable = liftIO $ do + path' <- textToCString path + let mode' = (fromIntegral . fromEnum) mode + options' <- unsafeManagedPtrGetPtr options + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_create_at dfd path' mode' options' maybeCancellable + checkUnexpectedReturnNULL "repoCreateAt" result + result' <- (wrapObject Repo) result + touchManagedPtr options + whenJust cancellable touchManagedPtr + freeMem path' + return result' + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::mode_from_string +-- method type : MemberFunction +-- Args : [Arg {argCName = "mode", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mode", argType = TInterface (Name {namespace = "OSTree", name = "RepoMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_mode_from_string" ostree_repo_mode_from_string :: + CString -> -- mode : TBasicType TUTF8 + CUInt -> -- out_mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoModeFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> OSTree.Enums.RepoMode + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoModeFromString mode outMode = liftIO $ do + mode' <- textToCString mode + let outMode' = (fromIntegral . fromEnum) outMode + onException (do + _ <- propagateGError $ ostree_repo_mode_from_string mode' outMode' + freeMem mode' + return () + ) (do + freeMem mode' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::open_at +-- method type : MemberFunction +-- Args : [Arg {argCName = "dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory fd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_open_at" ostree_repo_open_at :: + Int32 -> -- dfd : TBasicType TInt + CString -> -- path : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Repo) + +{- | +This combines 'GI.OSTree.Objects.Repo.repoNew' (but using fd-relative access) with +'GI.OSTree.Objects.Repo.repoOpen'. Use this when you know you should be operating on an +already extant repository. If you want to create one, use 'GI.OSTree.Objects.Repo.repoCreateAt'. +-} +repoOpenAt :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Int32 + {- ^ /@dfd@/: Directory fd -} + -> T.Text + {- ^ /@path@/: Path -} + -> Maybe (a) + -> m Repo + {- ^ __Returns:__ An accessor object for an OSTree repository located at /@dfd@/ + /@path@/ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoOpenAt dfd path cancellable = liftIO $ do + path' <- textToCString path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_open_at dfd path' maybeCancellable + checkUnexpectedReturnNULL "repoOpenAt" result + result' <- (wrapObject Repo) result + whenJust cancellable touchManagedPtr + freeMem path' + return result' + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repo::pull_default_console_progress_changed +-- method type : MemberFunction +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Async progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_pull_default_console_progress_changed" ostree_repo_pull_default_console_progress_changed :: + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Convenient \"changed\" callback for use with +'GI.OSTree.Objects.AsyncProgress.asyncProgressNewAndConnect' when pulling from a remote +repository. + +Depending on the state of the 'GI.OSTree.Objects.AsyncProgress.AsyncProgress', either displays a +custom status message, or else outstanding fetch progress in bytes\/sec, +or else outstanding content or metadata writes to the repository in +number of objects. + +Compatibility note: this function previously assumed that /@userData@/ +was a pointer to a @/GSConsole/@ instance. This is no longer the case, +and /@userData@/ is ignored. +-} +repoPullDefaultConsoleProgressChanged :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.AsyncProgress.IsAsyncProgress a) => + a + {- ^ /@progress@/: Async progress -} + -> Ptr () + {- ^ /@userData@/: User data -} + -> m () +repoPullDefaultConsoleProgressChanged progress userData = liftIO $ do + progress' <- unsafeManagedPtrCastPtr progress + ostree_repo_pull_default_console_progress_changed progress' userData + touchManagedPtr progress + return () + +#if ENABLE_OVERLOADING +#endif + +-- XXX Could not generate method Repo::traverse_new_parents +-- Error was : Not implemented: "GHashTable element of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoTraverseNewParentsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "traverseNewParents" Repo) => O.MethodInfo RepoTraverseNewParentsMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Repo::traverse_new_reachable +-- Error was : Not implemented: "GHashTable element of type TVariant unsupported." +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data RepoTraverseNewReachableMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "traverseNewReachable" Repo) => O.MethodInfo RepoTraverseNewReachableMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method Repo::traverse_parents_get_commits +-- method type : MemberFunction +-- Args : [Arg {argCName = "parents", argType = TGHash (TBasicType TPtr) (TBasicType TPtr), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_traverse_parents_get_commits" ostree_repo_traverse_parents_get_commits :: + Ptr (GHashTable (Ptr ()) (Ptr ())) -> -- parents : TGHash (TBasicType TPtr) (TBasicType TPtr) + Ptr GVariant -> -- object : TVariant + IO (Ptr CString) + +{- | +Gets all the commits that a certain object belongs to, as recorded +by a parents table gotten from ostree_repo_traverse_commit_union_with_parents. + +/Since: 2018.5/ +-} +repoTraverseParentsGetCommits :: + (B.CallStack.HasCallStack, MonadIO m) => + Map.Map (Ptr ()) (Ptr ()) + -> GVariant + -> m [T.Text] + {- ^ __Returns:__ An array of checksums for +the commits the key belongs to. -} +repoTraverseParentsGetCommits parents object = liftIO $ do + let parents' = Map.toList parents + let parents'' = mapFirst ptrPackPtr parents' + let parents''' = mapSecond ptrPackPtr parents'' + parents'''' <- packGHashTable gDirectHash gDirectEqual Nothing Nothing parents''' + object' <- unsafeManagedPtrGetPtr object + result <- ostree_repo_traverse_parents_get_commits parents'''' object' + checkUnexpectedReturnNULL "repoTraverseParentsGetCommits" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr object + unrefGHashTable parents'''' + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/Repo.hs-boot b/GI/OSTree/Objects/Repo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Repo.hs-boot @@ -0,0 +1,389 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.Repo 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype Repo = Repo (ManagedPtr Repo) +instance GObject Repo where +class (GObject o, O.IsDescendantOf Repo o) => IsRepo o +instance (GObject o, O.IsDescendantOf Repo o) => IsRepo o +instance O.HasParentTypes Repo +#if ENABLE_OVERLOADING +data RepoPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemotesConfigDirPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepoSysrootPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepoGpgVerifyResultSignalInfo +#endif +#if ENABLE_OVERLOADING +data RepoAbortTransactionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoAddGpgSignatureSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoAppendGpgSignatureMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCheckoutAtMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCheckoutGcMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCheckoutTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTransactionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCopyConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCreateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoDeleteObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFindRemotesAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFindRemotesFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFsckObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetBootloaderMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetCollectionIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetDefaultRepoFindersMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetDfdMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetDisableFsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetMinFreeSpaceBytesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetParentMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetRemoteBooleanOptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetRemoteListOptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGetRemoteOptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoGpgVerifyDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoHasObjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoHashMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoImportObjectFromMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoImportObjectFromWithTrustMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoIsSystemMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoIsWritableMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListCollectionRefsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListCommitObjectsStartingWithMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListObjectsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListRefsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListRefsExtMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoListStaticDeltaNamesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoLoadCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoLoadFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoLoadObjectStreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoLoadVariantMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoLoadVariantIfExistsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoMarkCommitPartialMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPrepareTransactionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPruneMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPruneFromReachableMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPruneStaticDeltasMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPullMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPullFromRemotesAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPullFromRemotesFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPullOneDirMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoPullWithOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoQueryObjectStorageSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoReadCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoReadCommitDetachedMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRegenerateSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoReloadConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteAddMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteChangeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteDeleteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteFetchSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteFetchSummaryWithOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteGetGpgVerifyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteGetGpgVerifySummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteGetUrlMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteGpgImportMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteListMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteListCollectionRefsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoRemoteListRefsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoResolveCollectionRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoResolveKeyringForCollectionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoResolveRevMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoResolveRevExtMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoScanHardlinksMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetAliasRefImmediateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetCacheDirMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetCollectionIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetCollectionRefImmediateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetDisableFsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSetRefImmediateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSignCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoSignDeltaMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoStaticDeltaExecuteOfflineMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoStaticDeltaGenerateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTransactionSetCollectionRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTransactionSetRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTransactionSetRefspecMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTraverseCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTraverseReachableRefsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoVerifyCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoVerifyCommitExtMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoVerifyCommitForRemoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoVerifySummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteArchiveToMtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteCommitDetachedMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteCommitWithTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteContentMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteContentAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteContentFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteContentTrustedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteDfdToMtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteDirectoryToMtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMetadataAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMetadataFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMetadataStreamTrustedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMetadataTrustedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoWriteMtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTraverseNewParentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoTraverseNewReachableMethodInfo +#endif diff --git a/GI/OSTree/Objects/RepoFile.hs b/GI/OSTree/Objects/RepoFile.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFile.hs @@ -0,0 +1,828 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.RepoFile + ( + +-- * Exported types + RepoFile(..) , + IsRepoFile , + toRepoFile , + noRepoFile , + + + -- * Methods +-- ** ensureResolved #method:ensureResolved# + +#if ENABLE_OVERLOADING + RepoFileEnsureResolvedMethodInfo , +#endif + repoFileEnsureResolved , + + +-- ** getChecksum #method:getChecksum# + +#if ENABLE_OVERLOADING + RepoFileGetChecksumMethodInfo , +#endif + repoFileGetChecksum , + + +-- ** getRepo #method:getRepo# + +#if ENABLE_OVERLOADING + RepoFileGetRepoMethodInfo , +#endif + repoFileGetRepo , + + +-- ** getRoot #method:getRoot# + +#if ENABLE_OVERLOADING + RepoFileGetRootMethodInfo , +#endif + repoFileGetRoot , + + +-- ** getXattrs #method:getXattrs# + +#if ENABLE_OVERLOADING + RepoFileGetXattrsMethodInfo , +#endif + repoFileGetXattrs , + + +-- ** treeFindChild #method:treeFindChild# + +#if ENABLE_OVERLOADING + RepoFileTreeFindChildMethodInfo , +#endif + repoFileTreeFindChild , + + +-- ** treeGetContents #method:treeGetContents# + +#if ENABLE_OVERLOADING + RepoFileTreeGetContentsMethodInfo , +#endif + repoFileTreeGetContents , + + +-- ** treeGetContentsChecksum #method:treeGetContentsChecksum# + +#if ENABLE_OVERLOADING + RepoFileTreeGetContentsChecksumMethodInfo, +#endif + repoFileTreeGetContentsChecksum , + + +-- ** treeGetMetadata #method:treeGetMetadata# + +#if ENABLE_OVERLOADING + RepoFileTreeGetMetadataMethodInfo , +#endif + repoFileTreeGetMetadata , + + +-- ** treeGetMetadataChecksum #method:treeGetMetadataChecksum# + +#if ENABLE_OVERLOADING + RepoFileTreeGetMetadataChecksumMethodInfo, +#endif + repoFileTreeGetMetadataChecksum , + + +-- ** treeQueryChild #method:treeQueryChild# + +#if ENABLE_OVERLOADING + RepoFileTreeQueryChildMethodInfo , +#endif + repoFileTreeQueryChild , + + +-- ** treeSetMetadata #method:treeSetMetadata# + +#if ENABLE_OVERLOADING + RepoFileTreeSetMetadataMethodInfo , +#endif + repoFileTreeSetMetadata , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Flags as Gio.Flags +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo + +-- | Memory-managed wrapper type. +newtype RepoFile = RepoFile (ManagedPtr RepoFile) +foreign import ccall "ostree_repo_file_get_type" + c_ostree_repo_file_get_type :: IO GType + +instance GObject RepoFile where + gobjectType = c_ostree_repo_file_get_type + + +-- | Type class for types which can be safely cast to `RepoFile`, for instance with `toRepoFile`. +class (GObject o, O.IsDescendantOf RepoFile o) => IsRepoFile o +instance (GObject o, O.IsDescendantOf RepoFile o) => IsRepoFile o + +instance O.HasParentTypes RepoFile +type instance O.ParentTypes RepoFile = '[GObject.Object.Object, Gio.File.File] + +-- | Cast to `RepoFile`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFile :: (MonadIO m, IsRepoFile o) => o -> m RepoFile +toRepoFile = liftIO . unsafeCastTo RepoFile + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFile`. +noRepoFile :: Maybe RepoFile +noRepoFile = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoFileMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFileMethod "appendTo" o = Gio.File.FileAppendToMethodInfo + ResolveRepoFileMethod "appendToAsync" o = Gio.File.FileAppendToAsyncMethodInfo + ResolveRepoFileMethod "appendToFinish" o = Gio.File.FileAppendToFinishMethodInfo + ResolveRepoFileMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFileMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFileMethod "copy" o = Gio.File.FileCopyMethodInfo + ResolveRepoFileMethod "copyAsync" o = Gio.File.FileCopyAsyncMethodInfo + ResolveRepoFileMethod "copyAttributes" o = Gio.File.FileCopyAttributesMethodInfo + ResolveRepoFileMethod "copyFinish" o = Gio.File.FileCopyFinishMethodInfo + ResolveRepoFileMethod "create" o = Gio.File.FileCreateMethodInfo + ResolveRepoFileMethod "createAsync" o = Gio.File.FileCreateAsyncMethodInfo + ResolveRepoFileMethod "createFinish" o = Gio.File.FileCreateFinishMethodInfo + ResolveRepoFileMethod "createReadwrite" o = Gio.File.FileCreateReadwriteMethodInfo + ResolveRepoFileMethod "createReadwriteAsync" o = Gio.File.FileCreateReadwriteAsyncMethodInfo + ResolveRepoFileMethod "createReadwriteFinish" o = Gio.File.FileCreateReadwriteFinishMethodInfo + ResolveRepoFileMethod "delete" o = Gio.File.FileDeleteMethodInfo + ResolveRepoFileMethod "deleteAsync" o = Gio.File.FileDeleteAsyncMethodInfo + ResolveRepoFileMethod "deleteFinish" o = Gio.File.FileDeleteFinishMethodInfo + ResolveRepoFileMethod "dup" o = Gio.File.FileDupMethodInfo + ResolveRepoFileMethod "ejectMountable" o = Gio.File.FileEjectMountableMethodInfo + ResolveRepoFileMethod "ejectMountableFinish" o = Gio.File.FileEjectMountableFinishMethodInfo + ResolveRepoFileMethod "ejectMountableWithOperation" o = Gio.File.FileEjectMountableWithOperationMethodInfo + ResolveRepoFileMethod "ejectMountableWithOperationFinish" o = Gio.File.FileEjectMountableWithOperationFinishMethodInfo + ResolveRepoFileMethod "ensureResolved" o = RepoFileEnsureResolvedMethodInfo + ResolveRepoFileMethod "enumerateChildren" o = Gio.File.FileEnumerateChildrenMethodInfo + ResolveRepoFileMethod "enumerateChildrenAsync" o = Gio.File.FileEnumerateChildrenAsyncMethodInfo + ResolveRepoFileMethod "enumerateChildrenFinish" o = Gio.File.FileEnumerateChildrenFinishMethodInfo + ResolveRepoFileMethod "equal" o = Gio.File.FileEqualMethodInfo + ResolveRepoFileMethod "findEnclosingMount" o = Gio.File.FileFindEnclosingMountMethodInfo + ResolveRepoFileMethod "findEnclosingMountAsync" o = Gio.File.FileFindEnclosingMountAsyncMethodInfo + ResolveRepoFileMethod "findEnclosingMountFinish" o = Gio.File.FileFindEnclosingMountFinishMethodInfo + ResolveRepoFileMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFileMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFileMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFileMethod "hasParent" o = Gio.File.FileHasParentMethodInfo + ResolveRepoFileMethod "hasPrefix" o = Gio.File.FileHasPrefixMethodInfo + ResolveRepoFileMethod "hasUriScheme" o = Gio.File.FileHasUriSchemeMethodInfo + ResolveRepoFileMethod "hash" o = Gio.File.FileHashMethodInfo + ResolveRepoFileMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFileMethod "isNative" o = Gio.File.FileIsNativeMethodInfo + ResolveRepoFileMethod "loadBytes" o = Gio.File.FileLoadBytesMethodInfo + ResolveRepoFileMethod "loadBytesAsync" o = Gio.File.FileLoadBytesAsyncMethodInfo + ResolveRepoFileMethod "loadBytesFinish" o = Gio.File.FileLoadBytesFinishMethodInfo + ResolveRepoFileMethod "loadContents" o = Gio.File.FileLoadContentsMethodInfo + ResolveRepoFileMethod "loadContentsAsync" o = Gio.File.FileLoadContentsAsyncMethodInfo + ResolveRepoFileMethod "loadContentsFinish" o = Gio.File.FileLoadContentsFinishMethodInfo + ResolveRepoFileMethod "loadPartialContentsFinish" o = Gio.File.FileLoadPartialContentsFinishMethodInfo + ResolveRepoFileMethod "makeDirectory" o = Gio.File.FileMakeDirectoryMethodInfo + ResolveRepoFileMethod "makeDirectoryAsync" o = Gio.File.FileMakeDirectoryAsyncMethodInfo + ResolveRepoFileMethod "makeDirectoryFinish" o = Gio.File.FileMakeDirectoryFinishMethodInfo + ResolveRepoFileMethod "makeDirectoryWithParents" o = Gio.File.FileMakeDirectoryWithParentsMethodInfo + ResolveRepoFileMethod "makeSymbolicLink" o = Gio.File.FileMakeSymbolicLinkMethodInfo + ResolveRepoFileMethod "measureDiskUsageFinish" o = Gio.File.FileMeasureDiskUsageFinishMethodInfo + ResolveRepoFileMethod "monitor" o = Gio.File.FileMonitorMethodInfo + ResolveRepoFileMethod "monitorDirectory" o = Gio.File.FileMonitorDirectoryMethodInfo + ResolveRepoFileMethod "monitorFile" o = Gio.File.FileMonitorFileMethodInfo + ResolveRepoFileMethod "mountEnclosingVolume" o = Gio.File.FileMountEnclosingVolumeMethodInfo + ResolveRepoFileMethod "mountEnclosingVolumeFinish" o = Gio.File.FileMountEnclosingVolumeFinishMethodInfo + ResolveRepoFileMethod "mountMountable" o = Gio.File.FileMountMountableMethodInfo + ResolveRepoFileMethod "mountMountableFinish" o = Gio.File.FileMountMountableFinishMethodInfo + ResolveRepoFileMethod "move" o = Gio.File.FileMoveMethodInfo + ResolveRepoFileMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFileMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFileMethod "openReadwrite" o = Gio.File.FileOpenReadwriteMethodInfo + ResolveRepoFileMethod "openReadwriteAsync" o = Gio.File.FileOpenReadwriteAsyncMethodInfo + ResolveRepoFileMethod "openReadwriteFinish" o = Gio.File.FileOpenReadwriteFinishMethodInfo + ResolveRepoFileMethod "peekPath" o = Gio.File.FilePeekPathMethodInfo + ResolveRepoFileMethod "pollMountable" o = Gio.File.FilePollMountableMethodInfo + ResolveRepoFileMethod "pollMountableFinish" o = Gio.File.FilePollMountableFinishMethodInfo + ResolveRepoFileMethod "queryDefaultHandler" o = Gio.File.FileQueryDefaultHandlerMethodInfo + ResolveRepoFileMethod "queryDefaultHandlerAsync" o = Gio.File.FileQueryDefaultHandlerAsyncMethodInfo + ResolveRepoFileMethod "queryDefaultHandlerFinish" o = Gio.File.FileQueryDefaultHandlerFinishMethodInfo + ResolveRepoFileMethod "queryExists" o = Gio.File.FileQueryExistsMethodInfo + ResolveRepoFileMethod "queryFileType" o = Gio.File.FileQueryFileTypeMethodInfo + ResolveRepoFileMethod "queryFilesystemInfo" o = Gio.File.FileQueryFilesystemInfoMethodInfo + ResolveRepoFileMethod "queryFilesystemInfoAsync" o = Gio.File.FileQueryFilesystemInfoAsyncMethodInfo + ResolveRepoFileMethod "queryFilesystemInfoFinish" o = Gio.File.FileQueryFilesystemInfoFinishMethodInfo + ResolveRepoFileMethod "queryInfo" o = Gio.File.FileQueryInfoMethodInfo + ResolveRepoFileMethod "queryInfoAsync" o = Gio.File.FileQueryInfoAsyncMethodInfo + ResolveRepoFileMethod "queryInfoFinish" o = Gio.File.FileQueryInfoFinishMethodInfo + ResolveRepoFileMethod "querySettableAttributes" o = Gio.File.FileQuerySettableAttributesMethodInfo + ResolveRepoFileMethod "queryWritableNamespaces" o = Gio.File.FileQueryWritableNamespacesMethodInfo + ResolveRepoFileMethod "read" o = Gio.File.FileReadMethodInfo + ResolveRepoFileMethod "readAsync" o = Gio.File.FileReadAsyncMethodInfo + ResolveRepoFileMethod "readFinish" o = Gio.File.FileReadFinishMethodInfo + ResolveRepoFileMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFileMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFileMethod "replace" o = Gio.File.FileReplaceMethodInfo + ResolveRepoFileMethod "replaceAsync" o = Gio.File.FileReplaceAsyncMethodInfo + ResolveRepoFileMethod "replaceContents" o = Gio.File.FileReplaceContentsMethodInfo + ResolveRepoFileMethod "replaceContentsAsync" o = Gio.File.FileReplaceContentsAsyncMethodInfo + ResolveRepoFileMethod "replaceContentsBytesAsync" o = Gio.File.FileReplaceContentsBytesAsyncMethodInfo + ResolveRepoFileMethod "replaceContentsFinish" o = Gio.File.FileReplaceContentsFinishMethodInfo + ResolveRepoFileMethod "replaceFinish" o = Gio.File.FileReplaceFinishMethodInfo + ResolveRepoFileMethod "replaceReadwrite" o = Gio.File.FileReplaceReadwriteMethodInfo + ResolveRepoFileMethod "replaceReadwriteAsync" o = Gio.File.FileReplaceReadwriteAsyncMethodInfo + ResolveRepoFileMethod "replaceReadwriteFinish" o = Gio.File.FileReplaceReadwriteFinishMethodInfo + ResolveRepoFileMethod "resolveRelativePath" o = Gio.File.FileResolveRelativePathMethodInfo + ResolveRepoFileMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFileMethod "startMountable" o = Gio.File.FileStartMountableMethodInfo + ResolveRepoFileMethod "startMountableFinish" o = Gio.File.FileStartMountableFinishMethodInfo + ResolveRepoFileMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFileMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFileMethod "stopMountable" o = Gio.File.FileStopMountableMethodInfo + ResolveRepoFileMethod "stopMountableFinish" o = Gio.File.FileStopMountableFinishMethodInfo + ResolveRepoFileMethod "supportsThreadContexts" o = Gio.File.FileSupportsThreadContextsMethodInfo + ResolveRepoFileMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFileMethod "trash" o = Gio.File.FileTrashMethodInfo + ResolveRepoFileMethod "trashAsync" o = Gio.File.FileTrashAsyncMethodInfo + ResolveRepoFileMethod "trashFinish" o = Gio.File.FileTrashFinishMethodInfo + ResolveRepoFileMethod "treeFindChild" o = RepoFileTreeFindChildMethodInfo + ResolveRepoFileMethod "treeGetContents" o = RepoFileTreeGetContentsMethodInfo + ResolveRepoFileMethod "treeGetContentsChecksum" o = RepoFileTreeGetContentsChecksumMethodInfo + ResolveRepoFileMethod "treeGetMetadata" o = RepoFileTreeGetMetadataMethodInfo + ResolveRepoFileMethod "treeGetMetadataChecksum" o = RepoFileTreeGetMetadataChecksumMethodInfo + ResolveRepoFileMethod "treeQueryChild" o = RepoFileTreeQueryChildMethodInfo + ResolveRepoFileMethod "treeSetMetadata" o = RepoFileTreeSetMetadataMethodInfo + ResolveRepoFileMethod "unmountMountable" o = Gio.File.FileUnmountMountableMethodInfo + ResolveRepoFileMethod "unmountMountableFinish" o = Gio.File.FileUnmountMountableFinishMethodInfo + ResolveRepoFileMethod "unmountMountableWithOperation" o = Gio.File.FileUnmountMountableWithOperationMethodInfo + ResolveRepoFileMethod "unmountMountableWithOperationFinish" o = Gio.File.FileUnmountMountableWithOperationFinishMethodInfo + ResolveRepoFileMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFileMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFileMethod "getBasename" o = Gio.File.FileGetBasenameMethodInfo + ResolveRepoFileMethod "getChecksum" o = RepoFileGetChecksumMethodInfo + ResolveRepoFileMethod "getChild" o = Gio.File.FileGetChildMethodInfo + ResolveRepoFileMethod "getChildForDisplayName" o = Gio.File.FileGetChildForDisplayNameMethodInfo + ResolveRepoFileMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFileMethod "getParent" o = Gio.File.FileGetParentMethodInfo + ResolveRepoFileMethod "getParseName" o = Gio.File.FileGetParseNameMethodInfo + ResolveRepoFileMethod "getPath" o = Gio.File.FileGetPathMethodInfo + ResolveRepoFileMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFileMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFileMethod "getRelativePath" o = Gio.File.FileGetRelativePathMethodInfo + ResolveRepoFileMethod "getRepo" o = RepoFileGetRepoMethodInfo + ResolveRepoFileMethod "getRoot" o = RepoFileGetRootMethodInfo + ResolveRepoFileMethod "getUri" o = Gio.File.FileGetUriMethodInfo + ResolveRepoFileMethod "getUriScheme" o = Gio.File.FileGetUriSchemeMethodInfo + ResolveRepoFileMethod "getXattrs" o = RepoFileGetXattrsMethodInfo + ResolveRepoFileMethod "setAttribute" o = Gio.File.FileSetAttributeMethodInfo + ResolveRepoFileMethod "setAttributeByteString" o = Gio.File.FileSetAttributeByteStringMethodInfo + ResolveRepoFileMethod "setAttributeInt32" o = Gio.File.FileSetAttributeInt32MethodInfo + ResolveRepoFileMethod "setAttributeInt64" o = Gio.File.FileSetAttributeInt64MethodInfo + ResolveRepoFileMethod "setAttributeString" o = Gio.File.FileSetAttributeStringMethodInfo + ResolveRepoFileMethod "setAttributeUint32" o = Gio.File.FileSetAttributeUint32MethodInfo + ResolveRepoFileMethod "setAttributeUint64" o = Gio.File.FileSetAttributeUint64MethodInfo + ResolveRepoFileMethod "setAttributesAsync" o = Gio.File.FileSetAttributesAsyncMethodInfo + ResolveRepoFileMethod "setAttributesFinish" o = Gio.File.FileSetAttributesFinishMethodInfo + ResolveRepoFileMethod "setAttributesFromInfo" o = Gio.File.FileSetAttributesFromInfoMethodInfo + ResolveRepoFileMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFileMethod "setDisplayName" o = Gio.File.FileSetDisplayNameMethodInfo + ResolveRepoFileMethod "setDisplayNameAsync" o = Gio.File.FileSetDisplayNameAsyncMethodInfo + ResolveRepoFileMethod "setDisplayNameFinish" o = Gio.File.FileSetDisplayNameFinishMethodInfo + ResolveRepoFileMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFileMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFileMethod t RepoFile, O.MethodInfo info RepoFile p) => OL.IsLabel t (RepoFile -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFile +type instance O.AttributeList RepoFile = RepoFileAttributeList +type RepoFileAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFile = RepoFileSignalList +type RepoFileSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RepoFile::ensure_resolved +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_file_ensure_resolved" ostree_repo_file_ensure_resolved :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoFileEnsureResolved :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFileEnsureResolved self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ ostree_repo_file_ensure_resolved self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoFileEnsureResolvedMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileEnsureResolvedMethodInfo a signature where + overloadedMethod _ = repoFileEnsureResolved + +#endif + +-- method RepoFile::get_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_get_checksum" ostree_repo_file_get_checksum :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +repoFileGetChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m T.Text +repoFileGetChecksum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_get_checksum self' + checkUnexpectedReturnNULL "repoFileGetChecksum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileGetChecksumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileGetChecksumMethodInfo a signature where + overloadedMethod _ = repoFileGetChecksum + +#endif + +-- method RepoFile::get_repo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_get_repo" ostree_repo_file_get_repo :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO (Ptr OSTree.Repo.Repo) + +{- | +/No description available in the introspection data./ +-} +repoFileGetRepo :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m OSTree.Repo.Repo + {- ^ __Returns:__ Repository -} +repoFileGetRepo self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_get_repo self' + checkUnexpectedReturnNULL "repoFileGetRepo" result + result' <- (newObject OSTree.Repo.Repo) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileGetRepoMethodInfo +instance (signature ~ (m OSTree.Repo.Repo), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileGetRepoMethodInfo a signature where + overloadedMethod _ = repoFileGetRepo + +#endif + +-- method RepoFile::get_root +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_get_root" ostree_repo_file_get_root :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO (Ptr RepoFile) + +{- | +/No description available in the introspection data./ +-} +repoFileGetRoot :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m RepoFile + {- ^ __Returns:__ The root directory for the commit referenced by this file -} +repoFileGetRoot self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_get_root self' + checkUnexpectedReturnNULL "repoFileGetRoot" result + result' <- (newObject RepoFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileGetRootMethodInfo +instance (signature ~ (m RepoFile), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileGetRootMethodInfo a signature where + overloadedMethod _ = repoFileGetRoot + +#endif + +-- method RepoFile::get_xattrs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_xattrs", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_file_get_xattrs" ostree_repo_file_get_xattrs :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Ptr GVariant -> -- out_xattrs : TVariant + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoFileGetXattrs :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a, Gio.Cancellable.IsCancellable b) => + a + -> GVariant + -> Maybe (b) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFileGetXattrs self outXattrs cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outXattrs' <- unsafeManagedPtrGetPtr outXattrs + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_file_get_xattrs self' outXattrs' maybeCancellable + touchManagedPtr self + touchManagedPtr outXattrs + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoFileGetXattrsMethodInfo +instance (signature ~ (GVariant -> Maybe (b) -> m ()), MonadIO m, IsRepoFile a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RepoFileGetXattrsMethodInfo a signature where + overloadedMethod _ = repoFileGetXattrs + +#endif + +-- method RepoFile::tree_find_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_dir", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_container", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_find_child" ostree_repo_file_tree_find_child :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + CString -> -- name : TBasicType TUTF8 + CInt -> -- is_dir : TBasicType TBoolean + Ptr GVariant -> -- out_container : TVariant + IO Int32 + +{- | +/No description available in the introspection data./ +-} +repoFileTreeFindChild :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> T.Text + -> Bool + -> GVariant + -> m Int32 +repoFileTreeFindChild self name isDir outContainer = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + let isDir' = (fromIntegral . fromEnum) isDir + outContainer' <- unsafeManagedPtrGetPtr outContainer + result <- ostree_repo_file_tree_find_child self' name' isDir' outContainer' + touchManagedPtr self + touchManagedPtr outContainer + freeMem name' + return result + +#if ENABLE_OVERLOADING +data RepoFileTreeFindChildMethodInfo +instance (signature ~ (T.Text -> Bool -> GVariant -> m Int32), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeFindChildMethodInfo a signature where + overloadedMethod _ = repoFileTreeFindChild + +#endif + +-- method RepoFile::tree_get_contents +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_get_contents" ostree_repo_file_tree_get_contents :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO (Ptr GVariant) + +{- | +/No description available in the introspection data./ +-} +repoFileTreeGetContents :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m GVariant +repoFileTreeGetContents self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_tree_get_contents self' + checkUnexpectedReturnNULL "repoFileTreeGetContents" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileTreeGetContentsMethodInfo +instance (signature ~ (m GVariant), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeGetContentsMethodInfo a signature where + overloadedMethod _ = repoFileTreeGetContents + +#endif + +-- method RepoFile::tree_get_contents_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_get_contents_checksum" ostree_repo_file_tree_get_contents_checksum :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +repoFileTreeGetContentsChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m T.Text +repoFileTreeGetContentsChecksum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_tree_get_contents_checksum self' + checkUnexpectedReturnNULL "repoFileTreeGetContentsChecksum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileTreeGetContentsChecksumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeGetContentsChecksumMethodInfo a signature where + overloadedMethod _ = repoFileTreeGetContentsChecksum + +#endif + +-- method RepoFile::tree_get_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_get_metadata" ostree_repo_file_tree_get_metadata :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO (Ptr GVariant) + +{- | +/No description available in the introspection data./ +-} +repoFileTreeGetMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m GVariant +repoFileTreeGetMetadata self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_tree_get_metadata self' + checkUnexpectedReturnNULL "repoFileTreeGetMetadata" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileTreeGetMetadataMethodInfo +instance (signature ~ (m GVariant), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeGetMetadataMethodInfo a signature where + overloadedMethod _ = repoFileTreeGetMetadata + +#endif + +-- method RepoFile::tree_get_metadata_checksum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_get_metadata_checksum" ostree_repo_file_tree_get_metadata_checksum :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +repoFileTreeGetMetadataChecksum :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> m T.Text +repoFileTreeGetMetadataChecksum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_repo_file_tree_get_metadata_checksum self' + checkUnexpectedReturnNULL "repoFileTreeGetMetadataChecksum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data RepoFileTreeGetMetadataChecksumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeGetMetadataChecksumMethodInfo a signature where + overloadedMethod _ = repoFileTreeGetMetadataChecksum + +#endif + +-- method RepoFile::tree_query_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "FileQueryInfoFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_query_child" ostree_repo_file_tree_query_child :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + Int32 -> -- n : TBasicType TInt + CString -> -- attributes : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "FileQueryInfoFlags"}) + Ptr Gio.FileInfo.FileInfo -> -- out_info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repoFileTreeQueryChild :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) => + a + -> Int32 + -> T.Text + -> [Gio.Flags.FileQueryInfoFlags] + -> b + -> Maybe (c) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFileTreeQueryChild self n attributes flags outInfo cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + attributes' <- textToCString attributes + let flags' = gflagsToWord flags + outInfo' <- unsafeManagedPtrCastPtr outInfo + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_repo_file_tree_query_child self' n attributes' flags' outInfo' maybeCancellable + touchManagedPtr self + touchManagedPtr outInfo + whenJust cancellable touchManagedPtr + freeMem attributes' + return () + ) (do + freeMem attributes' + ) + +#if ENABLE_OVERLOADING +data RepoFileTreeQueryChildMethodInfo +instance (signature ~ (Int32 -> T.Text -> [Gio.Flags.FileQueryInfoFlags] -> b -> Maybe (c) -> m ()), MonadIO m, IsRepoFile a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) => O.MethodInfo RepoFileTreeQueryChildMethodInfo a signature where + overloadedMethod _ = repoFileTreeQueryChild + +#endif + +-- method RepoFile::tree_set_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checksum", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metadata", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_file_tree_set_metadata" ostree_repo_file_tree_set_metadata :: + Ptr RepoFile -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFile"}) + CString -> -- checksum : TBasicType TUTF8 + Ptr GVariant -> -- metadata : TVariant + IO () + +{- | +/No description available in the introspection data./ +-} +repoFileTreeSetMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFile a) => + a + -> T.Text + -> GVariant + -> m () +repoFileTreeSetMetadata self checksum metadata = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + checksum' <- textToCString checksum + metadata' <- unsafeManagedPtrGetPtr metadata + ostree_repo_file_tree_set_metadata self' checksum' metadata' + touchManagedPtr self + touchManagedPtr metadata + freeMem checksum' + return () + +#if ENABLE_OVERLOADING +data RepoFileTreeSetMetadataMethodInfo +instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsRepoFile a) => O.MethodInfo RepoFileTreeSetMetadataMethodInfo a signature where + overloadedMethod _ = repoFileTreeSetMetadata + +#endif + + diff --git a/GI/OSTree/Objects/RepoFile.hs-boot b/GI/OSTree/Objects/RepoFile.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFile.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.RepoFile 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFile = RepoFile (ManagedPtr RepoFile) +instance GObject RepoFile where +class (GObject o, O.IsDescendantOf RepoFile o) => IsRepoFile o +instance (GObject o, O.IsDescendantOf RepoFile o) => IsRepoFile o +instance O.HasParentTypes RepoFile +#if ENABLE_OVERLOADING +data RepoFileEnsureResolvedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileGetChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileGetRepoMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileGetRootMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileGetXattrsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeFindChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeGetContentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeGetContentsChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeGetMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeGetMetadataChecksumMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeQueryChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFileTreeSetMetadataMethodInfo +#endif diff --git a/GI/OSTree/Objects/RepoFinderAvahi.hs b/GI/OSTree/Objects/RepoFinderAvahi.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderAvahi.hs @@ -0,0 +1,280 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.RepoFinderAvahi + ( + +-- * Exported types + RepoFinderAvahi(..) , + IsRepoFinderAvahi , + toRepoFinderAvahi , + noRepoFinderAvahi , + + + -- * Methods +-- ** new #method:new# + + repoFinderAvahiNew , + + +-- ** start #method:start# + +#if ENABLE_OVERLOADING + RepoFinderAvahiStartMethodInfo , +#endif + repoFinderAvahiStart , + + +-- ** stop #method:stop# + +#if ENABLE_OVERLOADING + RepoFinderAvahiStopMethodInfo , +#endif + repoFinderAvahiStop , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder + +-- | Memory-managed wrapper type. +newtype RepoFinderAvahi = RepoFinderAvahi (ManagedPtr RepoFinderAvahi) +foreign import ccall "ostree_repo_finder_avahi_get_type" + c_ostree_repo_finder_avahi_get_type :: IO GType + +instance GObject RepoFinderAvahi where + gobjectType = c_ostree_repo_finder_avahi_get_type + + +-- | Type class for types which can be safely cast to `RepoFinderAvahi`, for instance with `toRepoFinderAvahi`. +class (GObject o, O.IsDescendantOf RepoFinderAvahi o) => IsRepoFinderAvahi o +instance (GObject o, O.IsDescendantOf RepoFinderAvahi o) => IsRepoFinderAvahi o + +instance O.HasParentTypes RepoFinderAvahi +type instance O.ParentTypes RepoFinderAvahi = '[GObject.Object.Object, OSTree.RepoFinder.RepoFinder] + +-- | Cast to `RepoFinderAvahi`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFinderAvahi :: (MonadIO m, IsRepoFinderAvahi o) => o -> m RepoFinderAvahi +toRepoFinderAvahi = liftIO . unsafeCastTo RepoFinderAvahi + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinderAvahi`. +noRepoFinderAvahi :: Maybe RepoFinderAvahi +noRepoFinderAvahi = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderAvahiMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderAvahiMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFinderAvahiMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFinderAvahiMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFinderAvahiMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFinderAvahiMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFinderAvahiMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFinderAvahiMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFinderAvahiMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFinderAvahiMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFinderAvahiMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFinderAvahiMethod "resolveAsync" o = OSTree.RepoFinder.RepoFinderResolveAsyncMethodInfo + ResolveRepoFinderAvahiMethod "resolveFinish" o = OSTree.RepoFinder.RepoFinderResolveFinishMethodInfo + ResolveRepoFinderAvahiMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFinderAvahiMethod "start" o = RepoFinderAvahiStartMethodInfo + ResolveRepoFinderAvahiMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFinderAvahiMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFinderAvahiMethod "stop" o = RepoFinderAvahiStopMethodInfo + ResolveRepoFinderAvahiMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFinderAvahiMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFinderAvahiMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFinderAvahiMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFinderAvahiMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFinderAvahiMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFinderAvahiMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFinderAvahiMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFinderAvahiMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderAvahiMethod t RepoFinderAvahi, O.MethodInfo info RepoFinderAvahi p) => OL.IsLabel t (RepoFinderAvahi -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinderAvahi +type instance O.AttributeList RepoFinderAvahi = RepoFinderAvahiAttributeList +type RepoFinderAvahiAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFinderAvahi = RepoFinderAvahiSignalList +type RepoFinderAvahiSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RepoFinderAvahi::new +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "GLib", name = "MainContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFinderAvahi"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_avahi_new" ostree_repo_finder_avahi_new :: + Ptr GLib.MainContext.MainContext -> -- context : TInterface (Name {namespace = "GLib", name = "MainContext"}) + IO (Ptr RepoFinderAvahi) + +{- | +/No description available in the introspection data./ +-} +repoFinderAvahiNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GLib.MainContext.MainContext + -> m RepoFinderAvahi +repoFinderAvahiNew context = liftIO $ do + context' <- unsafeManagedPtrGetPtr context + result <- ostree_repo_finder_avahi_new context' + checkUnexpectedReturnNULL "repoFinderAvahiNew" result + result' <- (wrapObject RepoFinderAvahi) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method RepoFinderAvahi::start +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderAvahi"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderAvahi", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_finder_avahi_start" ostree_repo_finder_avahi_start :: + Ptr RepoFinderAvahi -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinderAvahi"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Start monitoring the local network for peers who are advertising OSTree +repositories, using Avahi. In order for this to work, the 'GI.GLib.Structs.MainContext.MainContext' +passed to /@self@/ at construction time must be iterated (so it will typically +be the global 'GI.GLib.Structs.MainContext.MainContext', or be a separate 'GI.GLib.Structs.MainContext.MainContext' in a worker +thread). + +This will return an error ('GI.Gio.Enums.IOErrorEnumFailed') if initialisation fails, or if +Avahi support is not available ('GI.Gio.Enums.IOErrorEnumNotSupported'). In either case, +the 'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi' instance is useless afterwards and should be +destroyed. + +Call 'GI.OSTree.Objects.RepoFinderAvahi.repoFinderAvahiStop' to stop the repo finder. + +It is an error to call this function multiple times on the same +'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi' instance, or to call it after +'GI.OSTree.Objects.RepoFinderAvahi.repoFinderAvahiStop'. + +/Since: 2018.6/ +-} +repoFinderAvahiStart :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFinderAvahi a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoFinderAvahiStart self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + propagateGError $ ostree_repo_finder_avahi_start self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoFinderAvahiStartMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepoFinderAvahi a) => O.MethodInfo RepoFinderAvahiStartMethodInfo a signature where + overloadedMethod _ = repoFinderAvahiStart + +#endif + +-- method RepoFinderAvahi::stop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderAvahi"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderAvahi", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_avahi_stop" ostree_repo_finder_avahi_stop :: + Ptr RepoFinderAvahi -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinderAvahi"}) + IO () + +{- | +Stop monitoring the local network for peers who are advertising OSTree +repositories. If any resolve tasks (from 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync') +are in progress, they will be cancelled and will return 'GI.Gio.Enums.IOErrorEnumCancelled'. + +Call 'GI.OSTree.Objects.RepoFinderAvahi.repoFinderAvahiStart' to start the repo finder. + +It is an error to call this function multiple times on the same +'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi' instance, or to call it before +'GI.OSTree.Objects.RepoFinderAvahi.repoFinderAvahiStart'. + +/Since: 2018.6/ +-} +repoFinderAvahiStop :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFinderAvahi a) => + a + {- ^ /@self@/: an 'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi' -} + -> m () +repoFinderAvahiStop self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_repo_finder_avahi_stop self' + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data RepoFinderAvahiStopMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepoFinderAvahi a) => O.MethodInfo RepoFinderAvahiStopMethodInfo a signature where + overloadedMethod _ = repoFinderAvahiStop + +#endif + + diff --git a/GI/OSTree/Objects/RepoFinderAvahi.hs-boot b/GI/OSTree/Objects/RepoFinderAvahi.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderAvahi.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.RepoFinderAvahi 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinderAvahi = RepoFinderAvahi (ManagedPtr RepoFinderAvahi) +instance GObject RepoFinderAvahi where +class (GObject o, O.IsDescendantOf RepoFinderAvahi o) => IsRepoFinderAvahi o +instance (GObject o, O.IsDescendantOf RepoFinderAvahi o) => IsRepoFinderAvahi o +instance O.HasParentTypes RepoFinderAvahi +#if ENABLE_OVERLOADING +data RepoFinderAvahiStartMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFinderAvahiStopMethodInfo +#endif diff --git a/GI/OSTree/Objects/RepoFinderConfig.hs b/GI/OSTree/Objects/RepoFinderConfig.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderConfig.hs @@ -0,0 +1,161 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.RepoFinderConfig + ( + +-- * Exported types + RepoFinderConfig(..) , + IsRepoFinderConfig , + toRepoFinderConfig , + noRepoFinderConfig , + + + -- * Methods +-- ** new #method:new# + + repoFinderConfigNew , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder + +-- | Memory-managed wrapper type. +newtype RepoFinderConfig = RepoFinderConfig (ManagedPtr RepoFinderConfig) +foreign import ccall "ostree_repo_finder_config_get_type" + c_ostree_repo_finder_config_get_type :: IO GType + +instance GObject RepoFinderConfig where + gobjectType = c_ostree_repo_finder_config_get_type + + +-- | Type class for types which can be safely cast to `RepoFinderConfig`, for instance with `toRepoFinderConfig`. +class (GObject o, O.IsDescendantOf RepoFinderConfig o) => IsRepoFinderConfig o +instance (GObject o, O.IsDescendantOf RepoFinderConfig o) => IsRepoFinderConfig o + +instance O.HasParentTypes RepoFinderConfig +type instance O.ParentTypes RepoFinderConfig = '[GObject.Object.Object, OSTree.RepoFinder.RepoFinder] + +-- | Cast to `RepoFinderConfig`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFinderConfig :: (MonadIO m, IsRepoFinderConfig o) => o -> m RepoFinderConfig +toRepoFinderConfig = liftIO . unsafeCastTo RepoFinderConfig + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinderConfig`. +noRepoFinderConfig :: Maybe RepoFinderConfig +noRepoFinderConfig = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderConfigMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderConfigMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFinderConfigMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFinderConfigMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFinderConfigMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFinderConfigMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFinderConfigMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFinderConfigMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFinderConfigMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFinderConfigMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFinderConfigMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFinderConfigMethod "resolveAsync" o = OSTree.RepoFinder.RepoFinderResolveAsyncMethodInfo + ResolveRepoFinderConfigMethod "resolveFinish" o = OSTree.RepoFinder.RepoFinderResolveFinishMethodInfo + ResolveRepoFinderConfigMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFinderConfigMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFinderConfigMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFinderConfigMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFinderConfigMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFinderConfigMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFinderConfigMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFinderConfigMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFinderConfigMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFinderConfigMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFinderConfigMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFinderConfigMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderConfigMethod t RepoFinderConfig, O.MethodInfo info RepoFinderConfig p) => OL.IsLabel t (RepoFinderConfig -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinderConfig +type instance O.AttributeList RepoFinderConfig = RepoFinderConfigAttributeList +type RepoFinderConfigAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFinderConfig = RepoFinderConfigSignalList +type RepoFinderConfigSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RepoFinderConfig::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFinderConfig"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_config_new" ostree_repo_finder_config_new :: + IO (Ptr RepoFinderConfig) + +{- | +Create a new 'GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig'. + +/Since: 2018.6/ +-} +repoFinderConfigNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m RepoFinderConfig + {- ^ __Returns:__ a new 'GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig' -} +repoFinderConfigNew = liftIO $ do + result <- ostree_repo_finder_config_new + checkUnexpectedReturnNULL "repoFinderConfigNew" result + result' <- (wrapObject RepoFinderConfig) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/RepoFinderConfig.hs-boot b/GI/OSTree/Objects/RepoFinderConfig.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderConfig.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.RepoFinderConfig 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinderConfig = RepoFinderConfig (ManagedPtr RepoFinderConfig) +instance GObject RepoFinderConfig where +class (GObject o, O.IsDescendantOf RepoFinderConfig o) => IsRepoFinderConfig o +instance (GObject o, O.IsDescendantOf RepoFinderConfig o) => IsRepoFinderConfig o +instance O.HasParentTypes RepoFinderConfig diff --git a/GI/OSTree/Objects/RepoFinderMount.hs b/GI/OSTree/Objects/RepoFinderMount.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderMount.hs @@ -0,0 +1,232 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.RepoFinderMount + ( + +-- * Exported types + RepoFinderMount(..) , + IsRepoFinderMount , + toRepoFinderMount , + noRepoFinderMount , + + + -- * Methods +-- ** new #method:new# + + repoFinderMountNew , + + + + + -- * Properties +-- ** monitor #attr:monitor# +{- | Volume monitor to use to look up mounted volumes when queried. + +/Since: 2018.6/ +-} +#if ENABLE_OVERLOADING + RepoFinderMountMonitorPropertyInfo , +#endif + constructRepoFinderMountMonitor , + getRepoFinderMountMonitor , +#if ENABLE_OVERLOADING + repoFinderMountMonitor , +#endif + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Objects.VolumeMonitor as Gio.VolumeMonitor +import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder + +-- | Memory-managed wrapper type. +newtype RepoFinderMount = RepoFinderMount (ManagedPtr RepoFinderMount) +foreign import ccall "ostree_repo_finder_mount_get_type" + c_ostree_repo_finder_mount_get_type :: IO GType + +instance GObject RepoFinderMount where + gobjectType = c_ostree_repo_finder_mount_get_type + + +-- | Type class for types which can be safely cast to `RepoFinderMount`, for instance with `toRepoFinderMount`. +class (GObject o, O.IsDescendantOf RepoFinderMount o) => IsRepoFinderMount o +instance (GObject o, O.IsDescendantOf RepoFinderMount o) => IsRepoFinderMount o + +instance O.HasParentTypes RepoFinderMount +type instance O.ParentTypes RepoFinderMount = '[GObject.Object.Object, OSTree.RepoFinder.RepoFinder] + +-- | Cast to `RepoFinderMount`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFinderMount :: (MonadIO m, IsRepoFinderMount o) => o -> m RepoFinderMount +toRepoFinderMount = liftIO . unsafeCastTo RepoFinderMount + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinderMount`. +noRepoFinderMount :: Maybe RepoFinderMount +noRepoFinderMount = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderMountMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderMountMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFinderMountMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFinderMountMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFinderMountMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFinderMountMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFinderMountMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFinderMountMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFinderMountMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFinderMountMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFinderMountMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFinderMountMethod "resolveAsync" o = OSTree.RepoFinder.RepoFinderResolveAsyncMethodInfo + ResolveRepoFinderMountMethod "resolveFinish" o = OSTree.RepoFinder.RepoFinderResolveFinishMethodInfo + ResolveRepoFinderMountMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFinderMountMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFinderMountMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFinderMountMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFinderMountMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFinderMountMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFinderMountMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFinderMountMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFinderMountMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFinderMountMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFinderMountMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFinderMountMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderMountMethod t RepoFinderMount, O.MethodInfo info RepoFinderMount p) => OL.IsLabel t (RepoFinderMount -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "monitor" + -- Type: TInterface (Name {namespace = "Gio", name = "VolumeMonitor"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@monitor@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoFinderMount #monitor +@ +-} +getRepoFinderMountMonitor :: (MonadIO m, IsRepoFinderMount o) => o -> m (Maybe Gio.VolumeMonitor.VolumeMonitor) +getRepoFinderMountMonitor obj = liftIO $ B.Properties.getObjectPropertyObject obj "monitor" Gio.VolumeMonitor.VolumeMonitor + +{- | +Construct a `GValueConstruct` with valid value for the “@monitor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepoFinderMountMonitor :: (IsRepoFinderMount o, Gio.VolumeMonitor.IsVolumeMonitor a) => a -> IO (GValueConstruct o) +constructRepoFinderMountMonitor val = B.Properties.constructObjectPropertyObject "monitor" (Just val) + +#if ENABLE_OVERLOADING +data RepoFinderMountMonitorPropertyInfo +instance AttrInfo RepoFinderMountMonitorPropertyInfo where + type AttrAllowedOps RepoFinderMountMonitorPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoFinderMountMonitorPropertyInfo = Gio.VolumeMonitor.IsVolumeMonitor + type AttrBaseTypeConstraint RepoFinderMountMonitorPropertyInfo = IsRepoFinderMount + type AttrGetType RepoFinderMountMonitorPropertyInfo = (Maybe Gio.VolumeMonitor.VolumeMonitor) + type AttrLabel RepoFinderMountMonitorPropertyInfo = "monitor" + type AttrOrigin RepoFinderMountMonitorPropertyInfo = RepoFinderMount + attrGet _ = getRepoFinderMountMonitor + attrSet _ = undefined + attrConstruct _ = constructRepoFinderMountMonitor + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinderMount +type instance O.AttributeList RepoFinderMount = RepoFinderMountAttributeList +type RepoFinderMountAttributeList = ('[ '("monitor", RepoFinderMountMonitorPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +repoFinderMountMonitor :: AttrLabelProxy "monitor" +repoFinderMountMonitor = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFinderMount = RepoFinderMountSignalList +type RepoFinderMountSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RepoFinderMount::new +-- method type : Constructor +-- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gio", name = "VolumeMonitor"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "volume monitor to use, or %NULL to use\n the system default", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFinderMount"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_mount_new" ostree_repo_finder_mount_new :: + Ptr Gio.VolumeMonitor.VolumeMonitor -> -- monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"}) + IO (Ptr RepoFinderMount) + +{- | +Create a new 'GI.OSTree.Objects.RepoFinderMount.RepoFinderMount', using the given /@monitor@/ to look up +volumes. If /@monitor@/ is 'Nothing', the monitor from 'GI.Gio.Objects.VolumeMonitor.volumeMonitorGet' will +be used. + +/Since: 2018.6/ +-} +repoFinderMountNew :: + (B.CallStack.HasCallStack, MonadIO m, Gio.VolumeMonitor.IsVolumeMonitor a) => + Maybe (a) + {- ^ /@monitor@/: volume monitor to use, or 'Nothing' to use + the system default -} + -> m RepoFinderMount + {- ^ __Returns:__ a new 'GI.OSTree.Objects.RepoFinderMount.RepoFinderMount' -} +repoFinderMountNew monitor = liftIO $ do + maybeMonitor <- case monitor of + Nothing -> return nullPtr + Just jMonitor -> do + jMonitor' <- unsafeManagedPtrCastPtr jMonitor + return jMonitor' + result <- ostree_repo_finder_mount_new maybeMonitor + checkUnexpectedReturnNULL "repoFinderMountNew" result + result' <- (wrapObject RepoFinderMount) result + whenJust monitor touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/RepoFinderMount.hs-boot b/GI/OSTree/Objects/RepoFinderMount.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderMount.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.RepoFinderMount 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinderMount = RepoFinderMount (ManagedPtr RepoFinderMount) +instance GObject RepoFinderMount where +class (GObject o, O.IsDescendantOf RepoFinderMount o) => IsRepoFinderMount o +instance (GObject o, O.IsDescendantOf RepoFinderMount o) => IsRepoFinderMount o +instance O.HasParentTypes RepoFinderMount +#if ENABLE_OVERLOADING +data RepoFinderMountMonitorPropertyInfo +#endif diff --git a/GI/OSTree/Objects/RepoFinderOverride.hs b/GI/OSTree/Objects/RepoFinderOverride.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderOverride.hs @@ -0,0 +1,210 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.RepoFinderOverride + ( + +-- * Exported types + RepoFinderOverride(..) , + IsRepoFinderOverride , + toRepoFinderOverride , + noRepoFinderOverride , + + + -- * Methods +-- ** addUri #method:addUri# + +#if ENABLE_OVERLOADING + RepoFinderOverrideAddUriMethodInfo , +#endif + repoFinderOverrideAddUri , + + +-- ** new #method:new# + + repoFinderOverrideNew , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder + +-- | Memory-managed wrapper type. +newtype RepoFinderOverride = RepoFinderOverride (ManagedPtr RepoFinderOverride) +foreign import ccall "ostree_repo_finder_override_get_type" + c_ostree_repo_finder_override_get_type :: IO GType + +instance GObject RepoFinderOverride where + gobjectType = c_ostree_repo_finder_override_get_type + + +-- | Type class for types which can be safely cast to `RepoFinderOverride`, for instance with `toRepoFinderOverride`. +class (GObject o, O.IsDescendantOf RepoFinderOverride o) => IsRepoFinderOverride o +instance (GObject o, O.IsDescendantOf RepoFinderOverride o) => IsRepoFinderOverride o + +instance O.HasParentTypes RepoFinderOverride +type instance O.ParentTypes RepoFinderOverride = '[GObject.Object.Object, OSTree.RepoFinder.RepoFinder] + +-- | Cast to `RepoFinderOverride`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepoFinderOverride :: (MonadIO m, IsRepoFinderOverride o) => o -> m RepoFinderOverride +toRepoFinderOverride = liftIO . unsafeCastTo RepoFinderOverride + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinderOverride`. +noRepoFinderOverride :: Maybe RepoFinderOverride +noRepoFinderOverride = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderOverrideMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderOverrideMethod "addUri" o = RepoFinderOverrideAddUriMethodInfo + ResolveRepoFinderOverrideMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepoFinderOverrideMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepoFinderOverrideMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepoFinderOverrideMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepoFinderOverrideMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepoFinderOverrideMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepoFinderOverrideMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepoFinderOverrideMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepoFinderOverrideMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepoFinderOverrideMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepoFinderOverrideMethod "resolveAsync" o = OSTree.RepoFinder.RepoFinderResolveAsyncMethodInfo + ResolveRepoFinderOverrideMethod "resolveFinish" o = OSTree.RepoFinder.RepoFinderResolveFinishMethodInfo + ResolveRepoFinderOverrideMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepoFinderOverrideMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepoFinderOverrideMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepoFinderOverrideMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepoFinderOverrideMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepoFinderOverrideMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepoFinderOverrideMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepoFinderOverrideMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepoFinderOverrideMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepoFinderOverrideMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepoFinderOverrideMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepoFinderOverrideMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderOverrideMethod t RepoFinderOverride, O.MethodInfo info RepoFinderOverride p) => OL.IsLabel t (RepoFinderOverride -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinderOverride +type instance O.AttributeList RepoFinderOverride = RepoFinderOverrideAttributeList +type RepoFinderOverrideAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RepoFinderOverride = RepoFinderOverrideSignalList +type RepoFinderOverrideSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RepoFinderOverride::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFinderOverride"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_override_new" ostree_repo_finder_override_new :: + IO (Ptr RepoFinderOverride) + +{- | +Create a new 'GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride'. + +/Since: 2018.6/ +-} +repoFinderOverrideNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m RepoFinderOverride + {- ^ __Returns:__ a new 'GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride' -} +repoFinderOverrideNew = liftIO $ do + result <- ostree_repo_finder_override_new + checkUnexpectedReturnNULL "repoFinderOverrideNew" result + result' <- (wrapObject RepoFinderOverride) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method RepoFinderOverride::add_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderOverride"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URI to add to the repo finder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_override_add_uri" ostree_repo_finder_override_add_uri :: + Ptr RepoFinderOverride -> -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinderOverride"}) + CString -> -- uri : TBasicType TUTF8 + IO () + +{- | +Add the given /@uri@/ to the set of URIs which the repo finder will search for +matching refs when 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' is called on it. + +/Since: 2018.6/ +-} +repoFinderOverrideAddUri :: + (B.CallStack.HasCallStack, MonadIO m, IsRepoFinderOverride a) => + a + -> T.Text + {- ^ /@uri@/: URI to add to the repo finder -} + -> m () +repoFinderOverrideAddUri self uri = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + uri' <- textToCString uri + ostree_repo_finder_override_add_uri self' uri' + touchManagedPtr self + freeMem uri' + return () + +#if ENABLE_OVERLOADING +data RepoFinderOverrideAddUriMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRepoFinderOverride a) => O.MethodInfo RepoFinderOverrideAddUriMethodInfo a signature where + overloadedMethod _ = repoFinderOverrideAddUri + +#endif + + diff --git a/GI/OSTree/Objects/RepoFinderOverride.hs-boot b/GI/OSTree/Objects/RepoFinderOverride.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/RepoFinderOverride.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.RepoFinderOverride 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinderOverride = RepoFinderOverride (ManagedPtr RepoFinderOverride) +instance GObject RepoFinderOverride where +class (GObject o, O.IsDescendantOf RepoFinderOverride o) => IsRepoFinderOverride o +instance (GObject o, O.IsDescendantOf RepoFinderOverride o) => IsRepoFinderOverride o +instance O.HasParentTypes RepoFinderOverride +#if ENABLE_OVERLOADING +data RepoFinderOverrideAddUriMethodInfo +#endif diff --git a/GI/OSTree/Objects/SePolicy.hs b/GI/OSTree/Objects/SePolicy.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/SePolicy.hs @@ -0,0 +1,720 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.SePolicy + ( + +-- * Exported types + SePolicy(..) , + IsSePolicy , + toSePolicy , + noSePolicy , + + + -- * Methods +-- ** fscreateconCleanup #method:fscreateconCleanup# + + sePolicyFscreateconCleanup , + + +-- ** getCsum #method:getCsum# + +#if ENABLE_OVERLOADING + SePolicyGetCsumMethodInfo , +#endif + sePolicyGetCsum , + + +-- ** getLabel #method:getLabel# + +#if ENABLE_OVERLOADING + SePolicyGetLabelMethodInfo , +#endif + sePolicyGetLabel , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + SePolicyGetNameMethodInfo , +#endif + sePolicyGetName , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + SePolicyGetPathMethodInfo , +#endif + sePolicyGetPath , + + +-- ** new #method:new# + + sePolicyNew , + + +-- ** newAt #method:newAt# + + sePolicyNewAt , + + +-- ** restorecon #method:restorecon# + +#if ENABLE_OVERLOADING + SePolicyRestoreconMethodInfo , +#endif + sePolicyRestorecon , + + +-- ** setfscreatecon #method:setfscreatecon# + +#if ENABLE_OVERLOADING + SePolicySetfscreateconMethodInfo , +#endif + sePolicySetfscreatecon , + + + + + -- * Properties +-- ** path #attr:path# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SePolicyPathPropertyInfo , +#endif + constructSePolicyPath , + getSePolicyPath , +#if ENABLE_OVERLOADING + sePolicyPath , +#endif + + +-- ** rootfsDfd #attr:rootfsDfd# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SePolicyRootfsDfdPropertyInfo , +#endif + constructSePolicyRootfsDfd , + getSePolicyRootfsDfd , +#if ENABLE_OVERLOADING + sePolicyRootfsDfd , +#endif + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Interfaces.Initable as Gio.Initable +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags + +-- | Memory-managed wrapper type. +newtype SePolicy = SePolicy (ManagedPtr SePolicy) +foreign import ccall "ostree_sepolicy_get_type" + c_ostree_sepolicy_get_type :: IO GType + +instance GObject SePolicy where + gobjectType = c_ostree_sepolicy_get_type + + +-- | Type class for types which can be safely cast to `SePolicy`, for instance with `toSePolicy`. +class (GObject o, O.IsDescendantOf SePolicy o) => IsSePolicy o +instance (GObject o, O.IsDescendantOf SePolicy o) => IsSePolicy o + +instance O.HasParentTypes SePolicy +type instance O.ParentTypes SePolicy = '[GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `SePolicy`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSePolicy :: (MonadIO m, IsSePolicy o) => o -> m SePolicy +toSePolicy = liftIO . unsafeCastTo SePolicy + +-- | A convenience alias for `Nothing` :: `Maybe` `SePolicy`. +noSePolicy :: Maybe SePolicy +noSePolicy = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSePolicyMethod (t :: Symbol) (o :: *) :: * where + ResolveSePolicyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSePolicyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSePolicyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSePolicyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSePolicyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSePolicyMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveSePolicyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSePolicyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSePolicyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSePolicyMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSePolicyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSePolicyMethod "restorecon" o = SePolicyRestoreconMethodInfo + ResolveSePolicyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSePolicyMethod "setfscreatecon" o = SePolicySetfscreateconMethodInfo + ResolveSePolicyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSePolicyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSePolicyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSePolicyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSePolicyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSePolicyMethod "getCsum" o = SePolicyGetCsumMethodInfo + ResolveSePolicyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSePolicyMethod "getLabel" o = SePolicyGetLabelMethodInfo + ResolveSePolicyMethod "getName" o = SePolicyGetNameMethodInfo + ResolveSePolicyMethod "getPath" o = SePolicyGetPathMethodInfo + ResolveSePolicyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSePolicyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSePolicyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSePolicyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSePolicyMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSePolicyMethod t SePolicy, O.MethodInfo info SePolicy p) => OL.IsLabel t (SePolicy -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "path" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sePolicy #path +@ +-} +getSePolicyPath :: (MonadIO m, IsSePolicy o) => o -> m Gio.File.File +getSePolicyPath obj = liftIO $ checkUnexpectedNothing "getSePolicyPath" $ B.Properties.getObjectPropertyObject obj "path" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSePolicyPath :: (IsSePolicy o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructSePolicyPath val = B.Properties.constructObjectPropertyObject "path" (Just val) + +#if ENABLE_OVERLOADING +data SePolicyPathPropertyInfo +instance AttrInfo SePolicyPathPropertyInfo where + type AttrAllowedOps SePolicyPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SePolicyPathPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint SePolicyPathPropertyInfo = IsSePolicy + type AttrGetType SePolicyPathPropertyInfo = Gio.File.File + type AttrLabel SePolicyPathPropertyInfo = "path" + type AttrOrigin SePolicyPathPropertyInfo = SePolicy + attrGet _ = getSePolicyPath + attrSet _ = undefined + attrConstruct _ = constructSePolicyPath + attrClear _ = undefined +#endif + +-- VVV Prop "rootfs-dfd" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@rootfs-dfd@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sePolicy #rootfsDfd +@ +-} +getSePolicyRootfsDfd :: (MonadIO m, IsSePolicy o) => o -> m Int32 +getSePolicyRootfsDfd obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "rootfs-dfd" + +{- | +Construct a `GValueConstruct` with valid value for the “@rootfs-dfd@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSePolicyRootfsDfd :: (IsSePolicy o) => Int32 -> IO (GValueConstruct o) +constructSePolicyRootfsDfd val = B.Properties.constructObjectPropertyInt32 "rootfs-dfd" val + +#if ENABLE_OVERLOADING +data SePolicyRootfsDfdPropertyInfo +instance AttrInfo SePolicyRootfsDfdPropertyInfo where + type AttrAllowedOps SePolicyRootfsDfdPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SePolicyRootfsDfdPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint SePolicyRootfsDfdPropertyInfo = IsSePolicy + type AttrGetType SePolicyRootfsDfdPropertyInfo = Int32 + type AttrLabel SePolicyRootfsDfdPropertyInfo = "rootfs-dfd" + type AttrOrigin SePolicyRootfsDfdPropertyInfo = SePolicy + attrGet _ = getSePolicyRootfsDfd + attrSet _ = undefined + attrConstruct _ = constructSePolicyRootfsDfd + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SePolicy +type instance O.AttributeList SePolicy = SePolicyAttributeList +type SePolicyAttributeList = ('[ '("path", SePolicyPathPropertyInfo), '("rootfsDfd", SePolicyRootfsDfdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +sePolicyPath :: AttrLabelProxy "path" +sePolicyPath = AttrLabelProxy + +sePolicyRootfsDfd :: AttrLabelProxy "rootfsDfd" +sePolicyRootfsDfd = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SePolicy = SePolicySignalList +type SePolicySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SePolicy::new +-- method type : Constructor +-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to a root directory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "SePolicy"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sepolicy_new" ostree_sepolicy_new :: + Ptr Gio.File.File -> -- path : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr SePolicy) + +{- | +/No description available in the introspection data./ +-} +sePolicyNew :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@path@/: Path to a root directory -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m SePolicy + {- ^ __Returns:__ An accessor object for SELinux policy in root located at /@path@/ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sePolicyNew path cancellable = liftIO $ do + path' <- unsafeManagedPtrCastPtr path + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_sepolicy_new path' maybeCancellable + checkUnexpectedReturnNULL "sePolicyNew" result + result' <- (wrapObject SePolicy) result + touchManagedPtr path + whenJust cancellable touchManagedPtr + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method SePolicy::new_at +-- method type : Constructor +-- Args : [Arg {argCName = "rootfs_dfd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Directory fd for rootfs (will not be cloned)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "SePolicy"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sepolicy_new_at" ostree_sepolicy_new_at :: + Int32 -> -- rootfs_dfd : TBasicType TInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr SePolicy) + +{- | +/No description available in the introspection data./ +-} +sePolicyNewAt :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + Int32 + {- ^ /@rootfsDfd@/: Directory fd for rootfs (will not be cloned) -} + -> Maybe (a) + {- ^ /@cancellable@/: Cancellable -} + -> m SePolicy + {- ^ __Returns:__ An accessor object for SELinux policy in root located at /@rootfsDfd@/ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sePolicyNewAt rootfsDfd cancellable = liftIO $ do + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_sepolicy_new_at rootfsDfd maybeCancellable + checkUnexpectedReturnNULL "sePolicyNewAt" result + result' <- (wrapObject SePolicy) result + whenJust cancellable touchManagedPtr + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method SePolicy::get_csum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sepolicy_get_csum" ostree_sepolicy_get_csum :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +sePolicyGetCsum :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a) => + a + -> m T.Text + {- ^ __Returns:__ Checksum of current policy -} +sePolicyGetCsum self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sepolicy_get_csum self' + checkUnexpectedReturnNULL "sePolicyGetCsum" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SePolicyGetCsumMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSePolicy a) => O.MethodInfo SePolicyGetCsumMethodInfo a signature where + overloadedMethod _ = sePolicyGetCsum + +#endif + +-- method SePolicy::get_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relpath", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unix_mode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Unix mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_label", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for security context", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sepolicy_get_label" ostree_sepolicy_get_label :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + CString -> -- relpath : TBasicType TUTF8 + Word32 -> -- unix_mode : TBasicType TUInt32 + Ptr CString -> -- out_label : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Store in /@outLabel@/ the security context for the given /@relpath@/ and +mode /@unixMode@/. If the policy does not specify a label, 'Nothing' +will be returned. +-} +sePolicyGetLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@relpath@/: Path -} + -> Word32 + {- ^ /@unixMode@/: Unix mode -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sePolicyGetLabel self relpath unixMode cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + relpath' <- textToCString relpath + outLabel <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sepolicy_get_label self' relpath' unixMode outLabel maybeCancellable + outLabel' <- peek outLabel + outLabel'' <- cstringToText outLabel' + freeMem outLabel' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem relpath' + freeMem outLabel + return outLabel'' + ) (do + freeMem relpath' + freeMem outLabel + ) + +#if ENABLE_OVERLOADING +data SePolicyGetLabelMethodInfo +instance (signature ~ (T.Text -> Word32 -> Maybe (b) -> m (T.Text)), MonadIO m, IsSePolicy a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SePolicyGetLabelMethodInfo a signature where + overloadedMethod _ = sePolicyGetLabel + +#endif + +-- method SePolicy::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sepolicy_get_name" ostree_sepolicy_get_name :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +sePolicyGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a) => + a + -> m T.Text + {- ^ __Returns:__ Type of current policy -} +sePolicyGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sepolicy_get_name self' + checkUnexpectedReturnNULL "sePolicyGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SePolicyGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSePolicy a) => O.MethodInfo SePolicyGetNameMethodInfo a signature where + overloadedMethod _ = sePolicyGetName + +#endif + +-- method SePolicy::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sepolicy_get_path" ostree_sepolicy_get_path :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ +-} +sePolicyGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a) => + a + -> m Gio.File.File + {- ^ __Returns:__ Path to rootfs -} +sePolicyGetPath self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sepolicy_get_path self' + checkUnexpectedReturnNULL "sePolicyGetPath" result + result' <- (newObject Gio.File.File) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SePolicyGetPathMethodInfo +instance (signature ~ (m Gio.File.File), MonadIO m, IsSePolicy a) => O.MethodInfo SePolicyGetPathMethodInfo a signature where + overloadedMethod _ = sePolicyGetPath + +#endif + +-- method SePolicy::restorecon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path string to use for policy lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Physical path to target file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "SePolicyRestoreconFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_new_label", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "New label, or %NULL if unchanged", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sepolicy_restorecon" ostree_sepolicy_restorecon :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + CString -> -- path : TBasicType TUTF8 + Ptr Gio.FileInfo.FileInfo -> -- info : TInterface (Name {namespace = "Gio", name = "FileInfo"}) + Ptr Gio.File.File -> -- target : TInterface (Name {namespace = "Gio", name = "File"}) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "SePolicyRestoreconFlags"}) + Ptr CString -> -- out_new_label : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Reset the security context of /@target@/ based on the SELinux policy. +-} +sePolicyRestorecon :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a, Gio.FileInfo.IsFileInfo b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@self@/: Self -} + -> T.Text + {- ^ /@path@/: Path string to use for policy lookup -} + -> Maybe (b) + {- ^ /@info@/: File attributes -} + -> c + {- ^ /@target@/: Physical path to target file -} + -> [OSTree.Flags.SePolicyRestoreconFlags] + {- ^ /@flags@/: Flags controlling behavior -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m (T.Text) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sePolicyRestorecon self path info target flags cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + maybeInfo <- case info of + Nothing -> return nullPtr + Just jInfo -> do + jInfo' <- unsafeManagedPtrCastPtr jInfo + return jInfo' + target' <- unsafeManagedPtrCastPtr target + let flags' = gflagsToWord flags + outNewLabel <- allocMem :: IO (Ptr CString) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sepolicy_restorecon self' path' maybeInfo target' flags' outNewLabel maybeCancellable + outNewLabel' <- peek outNewLabel + outNewLabel'' <- cstringToText outNewLabel' + freeMem outNewLabel' + touchManagedPtr self + whenJust info touchManagedPtr + touchManagedPtr target + whenJust cancellable touchManagedPtr + freeMem path' + freeMem outNewLabel + return outNewLabel'' + ) (do + freeMem path' + freeMem outNewLabel + ) + +#if ENABLE_OVERLOADING +data SePolicyRestoreconMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> c -> [OSTree.Flags.SePolicyRestoreconFlags] -> Maybe (d) -> m (T.Text)), MonadIO m, IsSePolicy a, Gio.FileInfo.IsFileInfo b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.MethodInfo SePolicyRestoreconMethodInfo a signature where + overloadedMethod _ = sePolicyRestorecon + +#endif + +-- method SePolicy::setfscreatecon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Policy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Use this path to determine a label", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Used along with @path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sepolicy_setfscreatecon" ostree_sepolicy_setfscreatecon :: + Ptr SePolicy -> -- self : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + CString -> -- path : TBasicType TUTF8 + Word32 -> -- mode : TBasicType TUInt32 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +sePolicySetfscreatecon :: + (B.CallStack.HasCallStack, MonadIO m, IsSePolicy a) => + a + {- ^ /@self@/: Policy -} + -> T.Text + {- ^ /@path@/: Use this path to determine a label -} + -> Word32 + {- ^ /@mode@/: Used along with /@path@/ -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sePolicySetfscreatecon self path mode = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + path' <- textToCString path + onException (do + _ <- propagateGError $ ostree_sepolicy_setfscreatecon self' path' mode + touchManagedPtr self + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data SePolicySetfscreateconMethodInfo +instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsSePolicy a) => O.MethodInfo SePolicySetfscreateconMethodInfo a signature where + overloadedMethod _ = sePolicySetfscreatecon + +#endif + +-- method SePolicy::fscreatecon_cleanup +-- method type : MemberFunction +-- Args : [Arg {argCName = "unused", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Not used, just in case you didn't infer that from the parameter name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sepolicy_fscreatecon_cleanup" ostree_sepolicy_fscreatecon_cleanup :: + Ptr () -> -- unused : TBasicType TPtr + IO () + +{- | +Cleanup function for 'GI.OSTree.Objects.SePolicy.sePolicySetfscreatecon'. +-} +sePolicyFscreateconCleanup :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + {- ^ /@unused@/: Not used, just in case you didn\'t infer that from the parameter name -} + -> m () +sePolicyFscreateconCleanup unused = liftIO $ do + ostree_sepolicy_fscreatecon_cleanup unused + return () + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/SePolicy.hs-boot b/GI/OSTree/Objects/SePolicy.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/SePolicy.hs-boot @@ -0,0 +1,53 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.SePolicy 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype SePolicy = SePolicy (ManagedPtr SePolicy) +instance GObject SePolicy where +class (GObject o, O.IsDescendantOf SePolicy o) => IsSePolicy o +instance (GObject o, O.IsDescendantOf SePolicy o) => IsSePolicy o +instance O.HasParentTypes SePolicy +#if ENABLE_OVERLOADING +data SePolicyPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyRootfsDfdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyGetCsumMethodInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyGetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data SePolicyRestoreconMethodInfo +#endif +#if ENABLE_OVERLOADING +data SePolicySetfscreateconMethodInfo +#endif diff --git a/GI/OSTree/Objects/Sysroot.hs b/GI/OSTree/Objects/Sysroot.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Sysroot.hs @@ -0,0 +1,2672 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.Sysroot + ( + +-- * Exported types + Sysroot(..) , + IsSysroot , + toSysroot , + noSysroot , + + + -- * Methods +-- ** cleanup #method:cleanup# + +#if ENABLE_OVERLOADING + SysrootCleanupMethodInfo , +#endif + sysrootCleanup , + + +-- ** cleanupPruneRepo #method:cleanupPruneRepo# + +#if ENABLE_OVERLOADING + SysrootCleanupPruneRepoMethodInfo , +#endif + sysrootCleanupPruneRepo , + + +-- ** deployTree #method:deployTree# + +#if ENABLE_OVERLOADING + SysrootDeployTreeMethodInfo , +#endif + sysrootDeployTree , + + +-- ** deploymentSetKargs #method:deploymentSetKargs# + +#if ENABLE_OVERLOADING + SysrootDeploymentSetKargsMethodInfo , +#endif + sysrootDeploymentSetKargs , + + +-- ** deploymentSetMutable #method:deploymentSetMutable# + +#if ENABLE_OVERLOADING + SysrootDeploymentSetMutableMethodInfo , +#endif + sysrootDeploymentSetMutable , + + +-- ** deploymentSetPinned #method:deploymentSetPinned# + +#if ENABLE_OVERLOADING + SysrootDeploymentSetPinnedMethodInfo , +#endif + sysrootDeploymentSetPinned , + + +-- ** deploymentUnlock #method:deploymentUnlock# + +#if ENABLE_OVERLOADING + SysrootDeploymentUnlockMethodInfo , +#endif + sysrootDeploymentUnlock , + + +-- ** ensureInitialized #method:ensureInitialized# + +#if ENABLE_OVERLOADING + SysrootEnsureInitializedMethodInfo , +#endif + sysrootEnsureInitialized , + + +-- ** getBootedDeployment #method:getBootedDeployment# + +#if ENABLE_OVERLOADING + SysrootGetBootedDeploymentMethodInfo , +#endif + sysrootGetBootedDeployment , + + +-- ** getBootversion #method:getBootversion# + +#if ENABLE_OVERLOADING + SysrootGetBootversionMethodInfo , +#endif + sysrootGetBootversion , + + +-- ** getDeploymentDirectory #method:getDeploymentDirectory# + +#if ENABLE_OVERLOADING + SysrootGetDeploymentDirectoryMethodInfo , +#endif + sysrootGetDeploymentDirectory , + + +-- ** getDeploymentDirpath #method:getDeploymentDirpath# + +#if ENABLE_OVERLOADING + SysrootGetDeploymentDirpathMethodInfo , +#endif + sysrootGetDeploymentDirpath , + + +-- ** getDeploymentOriginPath #method:getDeploymentOriginPath# + + sysrootGetDeploymentOriginPath , + + +-- ** getDeployments #method:getDeployments# + +#if ENABLE_OVERLOADING + SysrootGetDeploymentsMethodInfo , +#endif + sysrootGetDeployments , + + +-- ** getFd #method:getFd# + +#if ENABLE_OVERLOADING + SysrootGetFdMethodInfo , +#endif + sysrootGetFd , + + +-- ** getMergeDeployment #method:getMergeDeployment# + +#if ENABLE_OVERLOADING + SysrootGetMergeDeploymentMethodInfo , +#endif + sysrootGetMergeDeployment , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + SysrootGetPathMethodInfo , +#endif + sysrootGetPath , + + +-- ** getRepo #method:getRepo# + +#if ENABLE_OVERLOADING + SysrootGetRepoMethodInfo , +#endif + sysrootGetRepo , + + +-- ** getStagedDeployment #method:getStagedDeployment# + +#if ENABLE_OVERLOADING + SysrootGetStagedDeploymentMethodInfo , +#endif + sysrootGetStagedDeployment , + + +-- ** getSubbootversion #method:getSubbootversion# + +#if ENABLE_OVERLOADING + SysrootGetSubbootversionMethodInfo , +#endif + sysrootGetSubbootversion , + + +-- ** initOsname #method:initOsname# + +#if ENABLE_OVERLOADING + SysrootInitOsnameMethodInfo , +#endif + sysrootInitOsname , + + +-- ** load #method:load# + +#if ENABLE_OVERLOADING + SysrootLoadMethodInfo , +#endif + sysrootLoad , + + +-- ** loadIfChanged #method:loadIfChanged# + +#if ENABLE_OVERLOADING + SysrootLoadIfChangedMethodInfo , +#endif + sysrootLoadIfChanged , + + +-- ** lock #method:lock# + +#if ENABLE_OVERLOADING + SysrootLockMethodInfo , +#endif + sysrootLock , + + +-- ** lockAsync #method:lockAsync# + +#if ENABLE_OVERLOADING + SysrootLockAsyncMethodInfo , +#endif + sysrootLockAsync , + + +-- ** lockFinish #method:lockFinish# + +#if ENABLE_OVERLOADING + SysrootLockFinishMethodInfo , +#endif + sysrootLockFinish , + + +-- ** new #method:new# + + sysrootNew , + + +-- ** newDefault #method:newDefault# + + sysrootNewDefault , + + +-- ** originNewFromRefspec #method:originNewFromRefspec# + +#if ENABLE_OVERLOADING + SysrootOriginNewFromRefspecMethodInfo , +#endif + sysrootOriginNewFromRefspec , + + +-- ** prepareCleanup #method:prepareCleanup# + +#if ENABLE_OVERLOADING + SysrootPrepareCleanupMethodInfo , +#endif + sysrootPrepareCleanup , + + +-- ** queryDeploymentsFor #method:queryDeploymentsFor# + +#if ENABLE_OVERLOADING + SysrootQueryDeploymentsForMethodInfo , +#endif + sysrootQueryDeploymentsFor , + + +-- ** repo #method:repo# + +#if ENABLE_OVERLOADING + SysrootRepoMethodInfo , +#endif + sysrootRepo , + + +-- ** simpleWriteDeployment #method:simpleWriteDeployment# + +#if ENABLE_OVERLOADING + SysrootSimpleWriteDeploymentMethodInfo , +#endif + sysrootSimpleWriteDeployment , + + +-- ** stageTree #method:stageTree# + +#if ENABLE_OVERLOADING + SysrootStageTreeMethodInfo , +#endif + sysrootStageTree , + + +-- ** tryLock #method:tryLock# + +#if ENABLE_OVERLOADING + SysrootTryLockMethodInfo , +#endif + sysrootTryLock , + + +-- ** unload #method:unload# + +#if ENABLE_OVERLOADING + SysrootUnloadMethodInfo , +#endif + sysrootUnload , + + +-- ** unlock #method:unlock# + +#if ENABLE_OVERLOADING + SysrootUnlockMethodInfo , +#endif + sysrootUnlock , + + +-- ** writeDeployments #method:writeDeployments# + +#if ENABLE_OVERLOADING + SysrootWriteDeploymentsMethodInfo , +#endif + sysrootWriteDeployments , + + +-- ** writeDeploymentsWithOptions #method:writeDeploymentsWithOptions# + +#if ENABLE_OVERLOADING + SysrootWriteDeploymentsWithOptionsMethodInfo, +#endif + sysrootWriteDeploymentsWithOptions , + + +-- ** writeOriginFile #method:writeOriginFile# + +#if ENABLE_OVERLOADING + SysrootWriteOriginFileMethodInfo , +#endif + sysrootWriteOriginFile , + + + + + -- * Properties +-- ** path #attr:path# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SysrootPathPropertyInfo , +#endif + constructSysrootPath , + getSysrootPath , +#if ENABLE_OVERLOADING + sysrootPath , +#endif + + + + + -- * Signals +-- ** journalMsg #signal:journalMsg# + + C_SysrootJournalMsgCallback , + SysrootJournalMsgCallback , +#if ENABLE_OVERLOADING + SysrootJournalMsgSignalInfo , +#endif + afterSysrootJournalMsg , + genClosure_SysrootJournalMsg , + mk_SysrootJournalMsgCallback , + noSysrootJournalMsgCallback , + onSysrootJournalMsg , + wrap_SysrootJournalMsgCallback , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.KeyFile as GLib.KeyFile +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Objects.Deployment as OSTree.Deployment +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions +import {-# SOURCE #-} qualified GI.OSTree.Structs.SysrootWriteDeploymentsOpts as OSTree.SysrootWriteDeploymentsOpts + +-- | Memory-managed wrapper type. +newtype Sysroot = Sysroot (ManagedPtr Sysroot) +foreign import ccall "ostree_sysroot_get_type" + c_ostree_sysroot_get_type :: IO GType + +instance GObject Sysroot where + gobjectType = c_ostree_sysroot_get_type + + +-- | Type class for types which can be safely cast to `Sysroot`, for instance with `toSysroot`. +class (GObject o, O.IsDescendantOf Sysroot o) => IsSysroot o +instance (GObject o, O.IsDescendantOf Sysroot o) => IsSysroot o + +instance O.HasParentTypes Sysroot +type instance O.ParentTypes Sysroot = '[GObject.Object.Object] + +-- | Cast to `Sysroot`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSysroot :: (MonadIO m, IsSysroot o) => o -> m Sysroot +toSysroot = liftIO . unsafeCastTo Sysroot + +-- | A convenience alias for `Nothing` :: `Maybe` `Sysroot`. +noSysroot :: Maybe Sysroot +noSysroot = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSysrootMethod (t :: Symbol) (o :: *) :: * where + ResolveSysrootMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSysrootMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSysrootMethod "cleanup" o = SysrootCleanupMethodInfo + ResolveSysrootMethod "cleanupPruneRepo" o = SysrootCleanupPruneRepoMethodInfo + ResolveSysrootMethod "deployTree" o = SysrootDeployTreeMethodInfo + ResolveSysrootMethod "deploymentSetKargs" o = SysrootDeploymentSetKargsMethodInfo + ResolveSysrootMethod "deploymentSetMutable" o = SysrootDeploymentSetMutableMethodInfo + ResolveSysrootMethod "deploymentSetPinned" o = SysrootDeploymentSetPinnedMethodInfo + ResolveSysrootMethod "deploymentUnlock" o = SysrootDeploymentUnlockMethodInfo + ResolveSysrootMethod "ensureInitialized" o = SysrootEnsureInitializedMethodInfo + ResolveSysrootMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSysrootMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSysrootMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSysrootMethod "initOsname" o = SysrootInitOsnameMethodInfo + ResolveSysrootMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSysrootMethod "load" o = SysrootLoadMethodInfo + ResolveSysrootMethod "loadIfChanged" o = SysrootLoadIfChangedMethodInfo + ResolveSysrootMethod "lock" o = SysrootLockMethodInfo + ResolveSysrootMethod "lockAsync" o = SysrootLockAsyncMethodInfo + ResolveSysrootMethod "lockFinish" o = SysrootLockFinishMethodInfo + ResolveSysrootMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSysrootMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSysrootMethod "originNewFromRefspec" o = SysrootOriginNewFromRefspecMethodInfo + ResolveSysrootMethod "prepareCleanup" o = SysrootPrepareCleanupMethodInfo + ResolveSysrootMethod "queryDeploymentsFor" o = SysrootQueryDeploymentsForMethodInfo + ResolveSysrootMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSysrootMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSysrootMethod "repo" o = SysrootRepoMethodInfo + ResolveSysrootMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSysrootMethod "simpleWriteDeployment" o = SysrootSimpleWriteDeploymentMethodInfo + ResolveSysrootMethod "stageTree" o = SysrootStageTreeMethodInfo + ResolveSysrootMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSysrootMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSysrootMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSysrootMethod "tryLock" o = SysrootTryLockMethodInfo + ResolveSysrootMethod "unload" o = SysrootUnloadMethodInfo + ResolveSysrootMethod "unlock" o = SysrootUnlockMethodInfo + ResolveSysrootMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSysrootMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSysrootMethod "writeDeployments" o = SysrootWriteDeploymentsMethodInfo + ResolveSysrootMethod "writeDeploymentsWithOptions" o = SysrootWriteDeploymentsWithOptionsMethodInfo + ResolveSysrootMethod "writeOriginFile" o = SysrootWriteOriginFileMethodInfo + ResolveSysrootMethod "getBootedDeployment" o = SysrootGetBootedDeploymentMethodInfo + ResolveSysrootMethod "getBootversion" o = SysrootGetBootversionMethodInfo + ResolveSysrootMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSysrootMethod "getDeploymentDirectory" o = SysrootGetDeploymentDirectoryMethodInfo + ResolveSysrootMethod "getDeploymentDirpath" o = SysrootGetDeploymentDirpathMethodInfo + ResolveSysrootMethod "getDeployments" o = SysrootGetDeploymentsMethodInfo + ResolveSysrootMethod "getFd" o = SysrootGetFdMethodInfo + ResolveSysrootMethod "getMergeDeployment" o = SysrootGetMergeDeploymentMethodInfo + ResolveSysrootMethod "getPath" o = SysrootGetPathMethodInfo + ResolveSysrootMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSysrootMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSysrootMethod "getRepo" o = SysrootGetRepoMethodInfo + ResolveSysrootMethod "getStagedDeployment" o = SysrootGetStagedDeploymentMethodInfo + ResolveSysrootMethod "getSubbootversion" o = SysrootGetSubbootversionMethodInfo + ResolveSysrootMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSysrootMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSysrootMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSysrootMethod t Sysroot, O.MethodInfo info Sysroot p) => OL.IsLabel t (Sysroot -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- signal Sysroot::journal-msg +{- | +libostree will log to the journal various events, such as the \/etc merge +status, and transaction completion. Connect to this signal to also +synchronously receive the text for those messages. This is intended to be +used by command line tools which link to libostree as a library. + +Currently, the structured data is only available via the systemd journal. + +/Since: 2017.10/ +-} +type SysrootJournalMsgCallback = + T.Text + {- ^ /@msg@/: Human-readable string (should not contain newlines) -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `SysrootJournalMsgCallback`@. +noSysrootJournalMsgCallback :: Maybe SysrootJournalMsgCallback +noSysrootJournalMsgCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_SysrootJournalMsgCallback = + Ptr () -> -- object + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_SysrootJournalMsgCallback`. +foreign import ccall "wrapper" + mk_SysrootJournalMsgCallback :: C_SysrootJournalMsgCallback -> IO (FunPtr C_SysrootJournalMsgCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_SysrootJournalMsg :: MonadIO m => SysrootJournalMsgCallback -> m (GClosure C_SysrootJournalMsgCallback) +genClosure_SysrootJournalMsg cb = liftIO $ do + let cb' = wrap_SysrootJournalMsgCallback cb + mk_SysrootJournalMsgCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `SysrootJournalMsgCallback` into a `C_SysrootJournalMsgCallback`. +wrap_SysrootJournalMsgCallback :: + SysrootJournalMsgCallback -> + C_SysrootJournalMsgCallback +wrap_SysrootJournalMsgCallback _cb _ msg _ = do + msg' <- cstringToText msg + _cb msg' + + +{- | +Connect a signal handler for the “@journal-msg@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' sysroot #journalMsg callback +@ +-} +onSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> SysrootJournalMsgCallback -> m SignalHandlerId +onSysrootJournalMsg obj cb = liftIO $ do + let cb' = wrap_SysrootJournalMsgCallback cb + cb'' <- mk_SysrootJournalMsgCallback cb' + connectSignalFunPtr obj "journal-msg" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@journal-msg@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' sysroot #journalMsg callback +@ +-} +afterSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> SysrootJournalMsgCallback -> m SignalHandlerId +afterSysrootJournalMsg obj cb = liftIO $ do + let cb' = wrap_SysrootJournalMsgCallback cb + cb'' <- mk_SysrootJournalMsgCallback cb' + connectSignalFunPtr obj "journal-msg" cb'' SignalConnectAfter + + +-- VVV Prop "path" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sysroot #path +@ +-} +getSysrootPath :: (MonadIO m, IsSysroot o) => o -> m Gio.File.File +getSysrootPath obj = liftIO $ checkUnexpectedNothing "getSysrootPath" $ B.Properties.getObjectPropertyObject obj "path" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSysrootPath :: (IsSysroot o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructSysrootPath val = B.Properties.constructObjectPropertyObject "path" (Just val) + +#if ENABLE_OVERLOADING +data SysrootPathPropertyInfo +instance AttrInfo SysrootPathPropertyInfo where + type AttrAllowedOps SysrootPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SysrootPathPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint SysrootPathPropertyInfo = IsSysroot + type AttrGetType SysrootPathPropertyInfo = Gio.File.File + type AttrLabel SysrootPathPropertyInfo = "path" + type AttrOrigin SysrootPathPropertyInfo = Sysroot + attrGet _ = getSysrootPath + attrSet _ = undefined + attrConstruct _ = constructSysrootPath + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Sysroot +type instance O.AttributeList Sysroot = SysrootAttributeList +type SysrootAttributeList = ('[ '("path", SysrootPathPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +sysrootPath :: AttrLabelProxy "path" +sysrootPath = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data SysrootJournalMsgSignalInfo +instance SignalInfo SysrootJournalMsgSignalInfo where + type HaskellCallbackType SysrootJournalMsgSignalInfo = SysrootJournalMsgCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_SysrootJournalMsgCallback cb + cb'' <- mk_SysrootJournalMsgCallback cb' + connectSignalFunPtr obj "journal-msg" cb'' connectMode + +type instance O.SignalList Sysroot = SysrootSignalList +type SysrootSignalList = ('[ '("journalMsg", SysrootJournalMsgSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Sysroot::new +-- method type : Constructor +-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to a system root directory, or %NULL to use the\n current visible root file system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Sysroot"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_new" ostree_sysroot_new :: + Ptr Gio.File.File -> -- path : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr Sysroot) + +{- | +Create a new 'GI.OSTree.Objects.Sysroot.Sysroot' object for the sysroot at /@path@/. If /@path@/ is 'Nothing', +the current visible root file system is used, equivalent to +'GI.OSTree.Objects.Sysroot.sysrootNewDefault'. +-} +sysrootNew :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + Maybe (a) + {- ^ /@path@/: Path to a system root directory, or 'Nothing' to use the + current visible root file system -} + -> m Sysroot + {- ^ __Returns:__ An accessor object for an system root located at /@path@/ -} +sysrootNew path = liftIO $ do + maybePath <- case path of + Nothing -> return nullPtr + Just jPath -> do + jPath' <- unsafeManagedPtrCastPtr jPath + return jPath' + result <- ostree_sysroot_new maybePath + checkUnexpectedReturnNULL "sysrootNew" result + result' <- (wrapObject Sysroot) result + whenJust path touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Sysroot::new_default +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Sysroot"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_new_default" ostree_sysroot_new_default :: + IO (Ptr Sysroot) + +{- | +/No description available in the introspection data./ +-} +sysrootNewDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m Sysroot + {- ^ __Returns:__ An accessor for the current visible root \/ filesystem -} +sysrootNewDefault = liftIO $ do + result <- ostree_sysroot_new_default + checkUnexpectedReturnNULL "sysrootNewDefault" result + result' <- (wrapObject Sysroot) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Sysroot::cleanup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_cleanup" ostree_sysroot_cleanup :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete any state that resulted from a partially completed +transaction, such as incomplete deployments. +-} +sysrootCleanup :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootCleanup self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_cleanup self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootCleanupMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootCleanupMethodInfo a signature where + overloadedMethod _ = sysrootCleanup + +#endif + +-- method Sysroot::cleanup_prune_repo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling pruning", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_objects_total", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_objects_pruned", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_pruned_object_size_total", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Storage size in bytes of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_cleanup_prune_repo" ostree_sysroot_cleanup_prune_repo :: + Ptr Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.RepoPruneOptions.RepoPruneOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"}) + Ptr Int32 -> -- out_objects_total : TBasicType TInt + Ptr Int32 -> -- out_objects_pruned : TBasicType TInt + Ptr Word64 -> -- out_pruned_object_size_total : TBasicType TUInt64 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Prune the system repository. This is a thin wrapper +around 'GI.OSTree.Objects.Repo.repoPruneFromReachable'; the primary +addition is that this function automatically gathers +all deployed commits into the reachable set. + +You generally want to at least set the @OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY@ +flag in /@options@/. A commit traversal depth of @0@ is assumed. + +Locking: exclusive + +/Since: 2018.6/ +-} +sysrootCleanupPruneRepo :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@sysroot@/: Sysroot -} + -> OSTree.RepoPruneOptions.RepoPruneOptions + {- ^ /@options@/: Flags controlling pruning -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m ((Int32, Int32, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootCleanupPruneRepo sysroot options cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + options' <- unsafeManagedPtrGetPtr options + outObjectsTotal <- allocMem :: IO (Ptr Int32) + outObjectsPruned <- allocMem :: IO (Ptr Int32) + outPrunedObjectSizeTotal <- allocMem :: IO (Ptr Word64) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_cleanup_prune_repo sysroot' options' outObjectsTotal outObjectsPruned outPrunedObjectSizeTotal maybeCancellable + outObjectsTotal' <- peek outObjectsTotal + outObjectsPruned' <- peek outObjectsPruned + outPrunedObjectSizeTotal' <- peek outPrunedObjectSizeTotal + touchManagedPtr sysroot + touchManagedPtr options + whenJust cancellable touchManagedPtr + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + return (outObjectsTotal', outObjectsPruned', outPrunedObjectSizeTotal') + ) (do + freeMem outObjectsTotal + freeMem outObjectsPruned + freeMem outPrunedObjectSizeTotal + ) + +#if ENABLE_OVERLOADING +data SysrootCleanupPruneRepoMethodInfo +instance (signature ~ (OSTree.RepoPruneOptions.RepoPruneOptions -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootCleanupPruneRepoMethodInfo a signature where + overloadedMethod _ = sysrootCleanupPruneRepo + +#endif + +-- method Sysroot::deploy_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "osname to use for merge deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "revision", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin to use for upgrades", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "provided_merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for merge path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "override_kernel_argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use these as kernel arguments; if %NULL, inherit options from provided_merge_deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_deploy_tree" ostree_sysroot_deploy_tree :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + CString -> -- revision : TBasicType TUTF8 + Ptr GLib.KeyFile.KeyFile -> -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + Ptr OSTree.Deployment.Deployment -> -- provided_merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr CString -> -- override_kernel_argv : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check out deployment tree with revision /@revision@/, performing a 3 +way merge with /@providedMergeDeployment@/ for configuration. + +While this API is not deprecated, you most likely want to use the +'GI.OSTree.Objects.Sysroot.sysrootStageTree' API. +-} +sysrootDeployTree :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (T.Text) + {- ^ /@osname@/: osname to use for merge deployment -} + -> T.Text + {- ^ /@revision@/: Checksum to add -} + -> Maybe (GLib.KeyFile.KeyFile) + {- ^ /@origin@/: Origin to use for upgrades -} + -> Maybe (b) + {- ^ /@providedMergeDeployment@/: Use this deployment for merge path -} + -> Maybe ([T.Text]) + {- ^ /@overrideKernelArgv@/: Use these as kernel arguments; if 'Nothing', inherit options from provided_merge_deployment -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (OSTree.Deployment.Deployment) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootDeployTree self osname revision origin providedMergeDeployment overrideKernelArgv cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + revision' <- textToCString revision + maybeOrigin <- case origin of + Nothing -> return nullPtr + Just jOrigin -> do + jOrigin' <- unsafeManagedPtrGetPtr jOrigin + return jOrigin' + maybeProvidedMergeDeployment <- case providedMergeDeployment of + Nothing -> return nullPtr + Just jProvidedMergeDeployment -> do + jProvidedMergeDeployment' <- unsafeManagedPtrCastPtr jProvidedMergeDeployment + return jProvidedMergeDeployment' + maybeOverrideKernelArgv <- case overrideKernelArgv of + Nothing -> return nullPtr + Just jOverrideKernelArgv -> do + jOverrideKernelArgv' <- packZeroTerminatedUTF8CArray jOverrideKernelArgv + return jOverrideKernelArgv' + outNewDeployment <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_deploy_tree self' maybeOsname revision' maybeOrigin maybeProvidedMergeDeployment maybeOverrideKernelArgv outNewDeployment maybeCancellable + outNewDeployment' <- peek outNewDeployment + outNewDeployment'' <- (wrapObject OSTree.Deployment.Deployment) outNewDeployment' + touchManagedPtr self + whenJust origin touchManagedPtr + whenJust providedMergeDeployment touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeOsname + freeMem revision' + mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv + freeMem maybeOverrideKernelArgv + freeMem outNewDeployment + return outNewDeployment'' + ) (do + freeMem maybeOsname + freeMem revision' + mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv + freeMem maybeOverrideKernelArgv + freeMem outNewDeployment + ) + +#if ENABLE_OVERLOADING +data SysrootDeployTreeMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (b) -> Maybe ([T.Text]) -> Maybe (c) -> m (OSTree.Deployment.Deployment)), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeployTreeMethodInfo a signature where + overloadedMethod _ = sysrootDeployTree + +#endif + +-- method Sysroot::deployment_set_kargs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_kargs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Replace deployment's kernel arguments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_deployment_set_kargs" ostree_sysroot_deployment_set_kargs :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr CString -> -- new_kargs : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Entirely replace the kernel arguments of /@deployment@/ with the +values in /@newKargs@/. +-} +sysrootDeploymentSetKargs :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Sysroot -} + -> b + {- ^ /@deployment@/: A deployment -} + -> [T.Text] + {- ^ /@newKargs@/: Replace deployment\'s kernel arguments -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootDeploymentSetKargs self deployment newKargs cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + newKargs' <- packZeroTerminatedUTF8CArray newKargs + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_deployment_set_kargs self' deployment' newKargs' maybeCancellable + touchManagedPtr self + touchManagedPtr deployment + whenJust cancellable touchManagedPtr + mapZeroTerminatedCArray freeMem newKargs' + freeMem newKargs' + return () + ) (do + mapZeroTerminatedCArray freeMem newKargs' + freeMem newKargs' + ) + +#if ENABLE_OVERLOADING +data SysrootDeploymentSetKargsMethodInfo +instance (signature ~ (b -> [T.Text] -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentSetKargsMethodInfo a signature where + overloadedMethod _ = sysrootDeploymentSetKargs + +#endif + +-- method Sysroot::deployment_set_mutable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_mutable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not deployment's files can be changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_deployment_set_mutable" ostree_sysroot_deployment_set_mutable :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + CInt -> -- is_mutable : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +By default, deployment directories are not mutable. This function +will allow making them temporarily mutable, for example to allow +layering additional non-OSTree content. +-} +sysrootDeploymentSetMutable :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Sysroot -} + -> b + {- ^ /@deployment@/: A deployment -} + -> Bool + {- ^ /@isMutable@/: Whether or not deployment\'s files can be changed -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootDeploymentSetMutable self deployment isMutable cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + let isMutable' = (fromIntegral . fromEnum) isMutable + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_deployment_set_mutable self' deployment' isMutable' maybeCancellable + touchManagedPtr self + touchManagedPtr deployment + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootDeploymentSetMutableMethodInfo +instance (signature ~ (b -> Bool -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentSetMutableMethodInfo a signature where + overloadedMethod _ = sysrootDeploymentSetMutable + +#endif + +-- method Sysroot::deployment_set_pinned +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_pinned", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not deployment will be automatically GC'd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_deployment_set_pinned" ostree_sysroot_deployment_set_pinned :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + CInt -> -- is_pinned : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +By default, deployments may be subject to garbage collection. Typical uses of +libostree only retain at most 2 deployments. If /@isPinned@/ is @TRUE@, a +metadata bit will be set causing libostree to avoid automatic GC of the +deployment. However, this is really an \"advisory\" note; it\'s still possible +for e.g. older versions of libostree unaware of pinning to GC the deployment. + +This function does nothing and returns successfully if the deployment +is already in the desired pinning state. It is an error to try to pin +the staged deployment (as it\'s not in the bootloader entries). + +/Since: 2018.3/ +-} +sysrootDeploymentSetPinned :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => + a + {- ^ /@self@/: Sysroot -} + -> b + {- ^ /@deployment@/: A deployment -} + -> Bool + {- ^ /@isPinned@/: Whether or not deployment will be automatically GC\'d -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootDeploymentSetPinned self deployment isPinned = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + let isPinned' = (fromIntegral . fromEnum) isPinned + onException (do + _ <- propagateGError $ ostree_sysroot_deployment_set_pinned self' deployment' isPinned' + touchManagedPtr self + touchManagedPtr deployment + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootDeploymentSetPinnedMethodInfo +instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootDeploymentSetPinnedMethodInfo a signature where + overloadedMethod _ = sysrootDeploymentSetPinned + +#endif + +-- method Sysroot::deployment_unlock +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unlocked_state", argType = TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Transition to this unlocked state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_deployment_unlock" ostree_sysroot_deployment_unlock :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + CUInt -> -- unlocked_state : TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Configure the target deployment /@deployment@/ such that it +is writable. There are multiple modes, essentially differing +in whether or not any changes persist across reboot. + +The @OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX@ state is persistent +across reboots. +-} +sysrootDeploymentUnlock :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Sysroot -} + -> b + {- ^ /@deployment@/: Deployment -} + -> OSTree.Enums.DeploymentUnlockedState + {- ^ /@unlockedState@/: Transition to this unlocked state -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootDeploymentUnlock self deployment unlockedState cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + let unlockedState' = (fromIntegral . fromEnum) unlockedState + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_deployment_unlock self' deployment' unlockedState' maybeCancellable + touchManagedPtr self + touchManagedPtr deployment + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootDeploymentUnlockMethodInfo +instance (signature ~ (b -> OSTree.Enums.DeploymentUnlockedState -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentUnlockMethodInfo a signature where + overloadedMethod _ = sysrootDeploymentUnlock + +#endif + +-- method Sysroot::ensure_initialized +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_ensure_initialized" ostree_sysroot_ensure_initialized :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Ensure that /@self@/ is set up as a valid rootfs, by creating +\/ostree\/repo, among other things. +-} +sysrootEnsureInitialized :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootEnsureInitialized self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_ensure_initialized self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootEnsureInitializedMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootEnsureInitializedMethodInfo a signature where + overloadedMethod _ = sysrootEnsureInitialized + +#endif + +-- method Sysroot::get_booted_deployment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_booted_deployment" ostree_sysroot_get_booted_deployment :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO (Ptr OSTree.Deployment.Deployment) + +{- | +/No description available in the introspection data./ +-} +sysrootGetBootedDeployment :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m OSTree.Deployment.Deployment + {- ^ __Returns:__ The currently booted deployment, or 'Nothing' if none -} +sysrootGetBootedDeployment self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_booted_deployment self' + checkUnexpectedReturnNULL "sysrootGetBootedDeployment" result + result' <- (newObject OSTree.Deployment.Deployment) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootGetBootedDeploymentMethodInfo +instance (signature ~ (m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetBootedDeploymentMethodInfo a signature where + overloadedMethod _ = sysrootGetBootedDeployment + +#endif + +-- method Sysroot::get_bootversion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_bootversion" ostree_sysroot_get_bootversion :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +sysrootGetBootversion :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + -> m Int32 +sysrootGetBootversion self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_bootversion self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data SysrootGetBootversionMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetBootversionMethodInfo a signature where + overloadedMethod _ = sysrootGetBootversion + +#endif + +-- method Sysroot::get_deployment_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_deployment_directory" ostree_sysroot_get_deployment_directory :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ +-} +sysrootGetDeploymentDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => + a + {- ^ /@self@/: Sysroot -} + -> b + {- ^ /@deployment@/: A deployment -} + -> m Gio.File.File + {- ^ __Returns:__ Path to deployment root directory -} +sysrootGetDeploymentDirectory self deployment = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + result <- ostree_sysroot_get_deployment_directory self' deployment' + checkUnexpectedReturnNULL "sysrootGetDeploymentDirectory" result + result' <- (wrapObject Gio.File.File) result + touchManagedPtr self + touchManagedPtr deployment + return result' + +#if ENABLE_OVERLOADING +data SysrootGetDeploymentDirectoryMethodInfo +instance (signature ~ (b -> m Gio.File.File), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootGetDeploymentDirectoryMethodInfo a signature where + overloadedMethod _ = sysrootGetDeploymentDirectory + +#endif + +-- method Sysroot::get_deployment_dirpath +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_deployment_dirpath" ostree_sysroot_get_deployment_dirpath :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO CString + +{- | +Note this function only returns a *relative* path - if you want +to access, it, you must either use fd-relative api such as @/openat()/@, +or concatenate it with the full 'GI.OSTree.Objects.Sysroot.sysrootGetPath'. +-} +sysrootGetDeploymentDirpath :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => + a + {- ^ /@self@/: Repo -} + -> b + {- ^ /@deployment@/: A deployment -} + -> m T.Text + {- ^ __Returns:__ Path to deployment root directory, relative to sysroot -} +sysrootGetDeploymentDirpath self deployment = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + deployment' <- unsafeManagedPtrCastPtr deployment + result <- ostree_sysroot_get_deployment_dirpath self' deployment' + checkUnexpectedReturnNULL "sysrootGetDeploymentDirpath" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + touchManagedPtr deployment + return result' + +#if ENABLE_OVERLOADING +data SysrootGetDeploymentDirpathMethodInfo +instance (signature ~ (b -> m T.Text), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootGetDeploymentDirpathMethodInfo a signature where + overloadedMethod _ = sysrootGetDeploymentDirpath + +#endif + +-- method Sysroot::get_deployments +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_deployments" ostree_sysroot_get_deployments :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO (Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment))) + +{- | +/No description available in the introspection data./ +-} +sysrootGetDeployments :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m [OSTree.Deployment.Deployment] + {- ^ __Returns:__ Ordered list of deployments -} +sysrootGetDeployments self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_deployments self' + checkUnexpectedReturnNULL "sysrootGetDeployments" result + result' <- unpackGPtrArray result + result'' <- mapM (newObject OSTree.Deployment.Deployment) result' + unrefPtrArray result + touchManagedPtr self + return result'' + +#if ENABLE_OVERLOADING +data SysrootGetDeploymentsMethodInfo +instance (signature ~ (m [OSTree.Deployment.Deployment]), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetDeploymentsMethodInfo a signature where + overloadedMethod _ = sysrootGetDeployments + +#endif + +-- method Sysroot::get_fd +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_fd" ostree_sysroot_get_fd :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO Int32 + +{- | +Access a file descriptor that refers to the root directory of this +sysroot. 'GI.OSTree.Objects.Sysroot.sysrootLoad' must have been invoked prior to +calling this function. +-} +sysrootGetFd :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m Int32 + {- ^ __Returns:__ A file descriptor valid for the lifetime of /@self@/ -} +sysrootGetFd self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_fd self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data SysrootGetFdMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetFdMethodInfo a signature where + overloadedMethod _ = sysrootGetFd + +#endif + +-- method Sysroot::get_merge_deployment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Operating system group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_merge_deployment" ostree_sysroot_get_merge_deployment :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + IO (Ptr OSTree.Deployment.Deployment) + +{- | +Find the deployment to use as a configuration merge source; this is +the first one in the current deployment list which matches osname. +-} +sysrootGetMergeDeployment :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (T.Text) + {- ^ /@osname@/: Operating system group -} + -> m OSTree.Deployment.Deployment + {- ^ __Returns:__ Configuration merge deployment -} +sysrootGetMergeDeployment self osname = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + result <- ostree_sysroot_get_merge_deployment self' maybeOsname + checkUnexpectedReturnNULL "sysrootGetMergeDeployment" result + result' <- (wrapObject OSTree.Deployment.Deployment) result + touchManagedPtr self + freeMem maybeOsname + return result' + +#if ENABLE_OVERLOADING +data SysrootGetMergeDeploymentMethodInfo +instance (signature ~ (Maybe (T.Text) -> m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetMergeDeploymentMethodInfo a signature where + overloadedMethod _ = sysrootGetMergeDeployment + +#endif + +-- method Sysroot::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_path" ostree_sysroot_get_path :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ +-} +sysrootGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + -> m Gio.File.File + {- ^ __Returns:__ Path to rootfs -} +sysrootGetPath self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_path self' + checkUnexpectedReturnNULL "sysrootGetPath" result + result' <- (newObject Gio.File.File) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootGetPathMethodInfo +instance (signature ~ (m Gio.File.File), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetPathMethodInfo a signature where + overloadedMethod _ = sysrootGetPath + +#endif + +-- method Sysroot::get_repo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository in sysroot @self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_repo" ostree_sysroot_get_repo :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr (Ptr OSTree.Repo.Repo) -> -- out_repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Retrieve the OSTree repository in sysroot /@self@/. The repo is guaranteed to be open +(see 'GI.OSTree.Objects.Repo.repoOpen'). +-} +sysrootGetRepo :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m (OSTree.Repo.Repo) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootGetRepo self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outRepo <- allocMem :: IO (Ptr (Ptr OSTree.Repo.Repo)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_get_repo self' outRepo maybeCancellable + outRepo' <- peek outRepo + outRepo'' <- (wrapObject OSTree.Repo.Repo) outRepo' + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem outRepo + return outRepo'' + ) (do + freeMem outRepo + ) + +#if ENABLE_OVERLOADING +data SysrootGetRepoMethodInfo +instance (signature ~ (Maybe (b) -> m (OSTree.Repo.Repo)), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootGetRepoMethodInfo a signature where + overloadedMethod _ = sysrootGetRepo + +#endif + +-- method Sysroot::get_staged_deployment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_staged_deployment" ostree_sysroot_get_staged_deployment :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO (Ptr OSTree.Deployment.Deployment) + +{- | +/No description available in the introspection data./ +-} +sysrootGetStagedDeployment :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m OSTree.Deployment.Deployment + {- ^ __Returns:__ The currently staged deployment, or 'Nothing' if none -} +sysrootGetStagedDeployment self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_staged_deployment self' + checkUnexpectedReturnNULL "sysrootGetStagedDeployment" result + result' <- (newObject OSTree.Deployment.Deployment) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootGetStagedDeploymentMethodInfo +instance (signature ~ (m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetStagedDeploymentMethodInfo a signature where + overloadedMethod _ = sysrootGetStagedDeployment + +#endif + +-- method Sysroot::get_subbootversion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_subbootversion" ostree_sysroot_get_subbootversion :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +sysrootGetSubbootversion :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + -> m Int32 +sysrootGetSubbootversion self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_get_subbootversion self' + touchManagedPtr self + return result + +#if ENABLE_OVERLOADING +data SysrootGetSubbootversionMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetSubbootversionMethodInfo a signature where + overloadedMethod _ = sysrootGetSubbootversion + +#endif + +-- method Sysroot::init_osname +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name group of operating system checkouts", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_init_osname" ostree_sysroot_init_osname :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Initialize the directory structure for an \"osname\", which is a +group of operating system deployments, with a shared @\/var@. One +is required for generating a deployment. +-} +sysrootInitOsname :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> T.Text + {- ^ /@osname@/: Name group of operating system checkouts -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootInitOsname self osname cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + osname' <- textToCString osname + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_init_osname self' osname' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + freeMem osname' + return () + ) (do + freeMem osname' + ) + +#if ENABLE_OVERLOADING +data SysrootInitOsnameMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootInitOsnameMethodInfo a signature where + overloadedMethod _ = sysrootInitOsname + +#endif + +-- method Sysroot::load +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_load" ostree_sysroot_load :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Load deployment list, bootversion, and subbootversion from the +rootfs /@self@/. +-} +sysrootLoad :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootLoad self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_load self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootLoadMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootLoadMethodInfo a signature where + overloadedMethod _ = sysrootLoad + +#endif + +-- method Sysroot::load_if_changed +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_changed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_load_if_changed" ostree_sysroot_load_if_changed :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CInt -> -- out_changed : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +sysrootLoadIfChanged :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + -> Bool + -> Maybe (b) + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootLoadIfChanged self outChanged cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let outChanged' = (fromIntegral . fromEnum) outChanged + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_load_if_changed self' outChanged' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootLoadIfChangedMethodInfo +instance (signature ~ (Bool -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootLoadIfChangedMethodInfo a signature where + overloadedMethod _ = sysrootLoadIfChanged + +#endif + +-- method Sysroot::lock +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_lock" ostree_sysroot_lock :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Acquire an exclusive multi-process write lock for /@self@/. This call +blocks until the lock has been acquired. The lock is not +reentrant. + +Release the lock with 'GI.OSTree.Objects.Sysroot.sysrootUnlock'. The lock will also +be released if /@self@/ is deallocated. +-} +sysrootLock :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Self -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootLock self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ ostree_sysroot_lock self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootLockMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootLockMethodInfo a signature where + overloadedMethod _ = sysrootLock + +#endif + +-- method Sysroot::lock_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_lock_async" ostree_sysroot_lock_async :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +An asynchronous version of 'GI.OSTree.Objects.Sysroot.sysrootLock'. +-} +sysrootLockAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: Callback -} + -> m () +sysrootLockAsync self cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + ostree_sysroot_lock_async self' maybeCancellable maybeCallback userData + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SysrootLockAsyncMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootLockAsyncMethodInfo a signature where + overloadedMethod _ = sysrootLockAsync + +#endif + +-- method Sysroot::lock_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_lock_finish" ostree_sysroot_lock_finish :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Call when 'GI.OSTree.Objects.Sysroot.sysrootLockAsync' is ready. +-} +sysrootLockFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@self@/: Self -} + -> b + {- ^ /@result@/: Result -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootLockFinish self result_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ ostree_sysroot_lock_finish self' result_' + touchManagedPtr self + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootLockFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsSysroot a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SysrootLockFinishMethodInfo a signature where + overloadedMethod _ = sysrootLockFinish + +#endif + +-- method Sysroot::origin_new_from_refspec +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A refspec", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_origin_new_from_refspec" ostree_sysroot_origin_new_from_refspec :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- refspec : TBasicType TUTF8 + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +sysrootOriginNewFromRefspec :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> T.Text + {- ^ /@refspec@/: A refspec -} + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ A new config file which sets /@refspec@/ as an origin -} +sysrootOriginNewFromRefspec self refspec = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + refspec' <- textToCString refspec + result <- ostree_sysroot_origin_new_from_refspec self' refspec' + checkUnexpectedReturnNULL "sysrootOriginNewFromRefspec" result + result' <- (wrapBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + freeMem refspec' + return result' + +#if ENABLE_OVERLOADING +data SysrootOriginNewFromRefspecMethodInfo +instance (signature ~ (T.Text -> m GLib.KeyFile.KeyFile), MonadIO m, IsSysroot a) => O.MethodInfo SysrootOriginNewFromRefspecMethodInfo a signature where + overloadedMethod _ = sysrootOriginNewFromRefspec + +#endif + +-- method Sysroot::prepare_cleanup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_prepare_cleanup" ostree_sysroot_prepare_cleanup :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.Sysroot.sysrootCleanup' in that it cleans up incomplete deployments +and old boot versions, but does NOT prune the repository. +-} +sysrootPrepareCleanup :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootPrepareCleanup self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_prepare_cleanup self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootPrepareCleanupMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootPrepareCleanupMethodInfo a signature where + overloadedMethod _ = sysrootPrepareCleanup + +#endif + +-- method Sysroot::query_deployments_for +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\"stateroot\" name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_pending", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pending deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_rollback", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The rollback deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_query_deployments_for" ostree_sysroot_query_deployments_for :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_pending : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_rollback : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + IO () + +{- | +Find the pending and rollback deployments for /@osname@/. Pass 'Nothing' for /@osname@/ +to use the booted deployment\'s osname. By default, pending deployment is the +first deployment in the order that matches /@osname@/, and /@rollback@/ will be the +next one after the booted deployment, or the deployment after the pending if +we\'re not looking at the booted deployment. + +/Since: 2017.7/ +-} +sysrootQueryDeploymentsFor :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (T.Text) + {- ^ /@osname@/: \"stateroot\" name -} + -> m ((OSTree.Deployment.Deployment, OSTree.Deployment.Deployment)) +sysrootQueryDeploymentsFor self osname = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + outPending <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment)) + outRollback <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment)) + ostree_sysroot_query_deployments_for self' maybeOsname outPending outRollback + outPending' <- peek outPending + outPending'' <- (wrapObject OSTree.Deployment.Deployment) outPending' + outRollback' <- peek outRollback + outRollback'' <- (wrapObject OSTree.Deployment.Deployment) outRollback' + touchManagedPtr self + freeMem maybeOsname + freeMem outPending + freeMem outRollback + return (outPending'', outRollback'') + +#if ENABLE_OVERLOADING +data SysrootQueryDeploymentsForMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ((OSTree.Deployment.Deployment, OSTree.Deployment.Deployment))), MonadIO m, IsSysroot a) => O.MethodInfo SysrootQueryDeploymentsForMethodInfo a signature where + overloadedMethod _ = sysrootQueryDeploymentsFor + +#endif + +-- method Sysroot::repo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_repo" ostree_sysroot_repo :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO (Ptr OSTree.Repo.Repo) + +{- | +This function is a variant of 'GI.OSTree.Objects.Sysroot.sysrootGetRepo' that cannot fail, and +returns a cached repository. Can only be called after 'GI.OSTree.Objects.Sysroot.sysrootLoad' +has been invoked successfully. +-} +sysrootRepo :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m OSTree.Repo.Repo + {- ^ __Returns:__ The OSTree repository in sysroot /@self@/. -} +sysrootRepo self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_repo self' + checkUnexpectedReturnNULL "sysrootRepo" result + result' <- (newObject OSTree.Repo.Repo) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootRepoMethodInfo +instance (signature ~ (m OSTree.Repo.Repo), MonadIO m, IsSysroot a) => O.MethodInfo SysrootRepoMethodInfo a signature where + overloadedMethod _ = sysrootRepo + +#endif + +-- method Sysroot::simple_write_deployment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "OS name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Prepend this deployment to the list", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for configuration merge", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "SysrootSimpleWriteDeploymentFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_simple_write_deployment" ostree_sysroot_simple_write_deployment :: + Ptr Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + Ptr OSTree.Deployment.Deployment -> -- new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr OSTree.Deployment.Deployment -> -- merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "SysrootSimpleWriteDeploymentFlags"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Prepend /@newDeployment@/ to the list of deployments, commit, and +cleanup. By default, all other deployments for the given /@osname@/ +except the merge deployment and the booted deployment will be +garbage collected. + +If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetain' is +specified, then all current deployments will be kept. + +If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetainPending' is +specified, then pending deployments will be kept. + +If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetainRollback' is +specified, then rollback deployments will be kept. + +If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsNotDefault' is +specified, then instead of prepending, the new deployment will be +added right after the booted or merge deployment, instead of first. + +If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsNoClean' is +specified, then no cleanup will be performed after adding the +deployment. Make sure to call 'GI.OSTree.Objects.Sysroot.sysrootCleanup' sometime +later, instead. +-} +sysrootSimpleWriteDeployment :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, OSTree.Deployment.IsDeployment c, Gio.Cancellable.IsCancellable d) => + a + {- ^ /@sysroot@/: Sysroot -} + -> Maybe (T.Text) + {- ^ /@osname@/: OS name -} + -> b + {- ^ /@newDeployment@/: Prepend this deployment to the list -} + -> Maybe (c) + {- ^ /@mergeDeployment@/: Use this deployment for configuration merge -} + -> [OSTree.Flags.SysrootSimpleWriteDeploymentFlags] + {- ^ /@flags@/: Flags controlling behavior -} + -> Maybe (d) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootSimpleWriteDeployment sysroot osname newDeployment mergeDeployment flags cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + newDeployment' <- unsafeManagedPtrCastPtr newDeployment + maybeMergeDeployment <- case mergeDeployment of + Nothing -> return nullPtr + Just jMergeDeployment -> do + jMergeDeployment' <- unsafeManagedPtrCastPtr jMergeDeployment + return jMergeDeployment' + let flags' = gflagsToWord flags + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_simple_write_deployment sysroot' maybeOsname newDeployment' maybeMergeDeployment flags' maybeCancellable + touchManagedPtr sysroot + touchManagedPtr newDeployment + whenJust mergeDeployment touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeOsname + return () + ) (do + freeMem maybeOsname + ) + +#if ENABLE_OVERLOADING +data SysrootSimpleWriteDeploymentMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> Maybe (c) -> [OSTree.Flags.SysrootSimpleWriteDeploymentFlags] -> Maybe (d) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, OSTree.Deployment.IsDeployment c, Gio.Cancellable.IsCancellable d) => O.MethodInfo SysrootSimpleWriteDeploymentMethodInfo a signature where + overloadedMethod _ = sysrootSimpleWriteDeployment + +#endif + +-- method Sysroot::stage_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "osname to use for merge deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "revision", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin to use for upgrades", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for merge path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "override_kernel_argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use these as kernel arguments; if %NULL, inherit options from provided_merge_deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_stage_tree" ostree_sysroot_stage_tree :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + CString -> -- revision : TBasicType TUTF8 + Ptr GLib.KeyFile.KeyFile -> -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + Ptr OSTree.Deployment.Deployment -> -- merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr CString -> -- override_kernel_argv : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.Sysroot.sysrootDeployTree', but \"finalization\" only occurs at OS +shutdown time. +-} +sysrootStageTree :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (T.Text) + {- ^ /@osname@/: osname to use for merge deployment -} + -> T.Text + {- ^ /@revision@/: Checksum to add -} + -> Maybe (GLib.KeyFile.KeyFile) + {- ^ /@origin@/: Origin to use for upgrades -} + -> Maybe (b) + {- ^ /@mergeDeployment@/: Use this deployment for merge path -} + -> Maybe ([T.Text]) + {- ^ /@overrideKernelArgv@/: Use these as kernel arguments; if 'Nothing', inherit options from provided_merge_deployment -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (OSTree.Deployment.Deployment) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootStageTree self osname revision origin mergeDeployment overrideKernelArgv cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + revision' <- textToCString revision + maybeOrigin <- case origin of + Nothing -> return nullPtr + Just jOrigin -> do + jOrigin' <- unsafeManagedPtrGetPtr jOrigin + return jOrigin' + maybeMergeDeployment <- case mergeDeployment of + Nothing -> return nullPtr + Just jMergeDeployment -> do + jMergeDeployment' <- unsafeManagedPtrCastPtr jMergeDeployment + return jMergeDeployment' + maybeOverrideKernelArgv <- case overrideKernelArgv of + Nothing -> return nullPtr + Just jOverrideKernelArgv -> do + jOverrideKernelArgv' <- packZeroTerminatedUTF8CArray jOverrideKernelArgv + return jOverrideKernelArgv' + outNewDeployment <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment)) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_stage_tree self' maybeOsname revision' maybeOrigin maybeMergeDeployment maybeOverrideKernelArgv outNewDeployment maybeCancellable + outNewDeployment' <- peek outNewDeployment + outNewDeployment'' <- (wrapObject OSTree.Deployment.Deployment) outNewDeployment' + touchManagedPtr self + whenJust origin touchManagedPtr + whenJust mergeDeployment touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeOsname + freeMem revision' + mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv + freeMem maybeOverrideKernelArgv + freeMem outNewDeployment + return outNewDeployment'' + ) (do + freeMem maybeOsname + freeMem revision' + mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv + freeMem maybeOverrideKernelArgv + freeMem outNewDeployment + ) + +#if ENABLE_OVERLOADING +data SysrootStageTreeMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (b) -> Maybe ([T.Text]) -> Maybe (c) -> m (OSTree.Deployment.Deployment)), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootStageTreeMethodInfo a signature where + overloadedMethod _ = sysrootStageTree + +#endif + +-- method Sysroot::try_lock +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_acquired", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the lock has been acquired", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_try_lock" ostree_sysroot_try_lock :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr CInt -> -- out_acquired : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Try to acquire an exclusive multi-process write lock for /@self@/. If +another process holds the lock, this function will return +immediately, setting /@outAcquired@/ to 'False', and returning 'True' +(and no error). + +Release the lock with 'GI.OSTree.Objects.Sysroot.sysrootUnlock'. The lock will also +be released if /@self@/ is deallocated. +-} +sysrootTryLock :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Self -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootTryLock self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outAcquired <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ ostree_sysroot_try_lock self' outAcquired + outAcquired' <- peek outAcquired + let outAcquired'' = (/= 0) outAcquired' + touchManagedPtr self + freeMem outAcquired + return outAcquired'' + ) (do + freeMem outAcquired + ) + +#if ENABLE_OVERLOADING +data SysrootTryLockMethodInfo +instance (signature ~ (m (Bool)), MonadIO m, IsSysroot a) => O.MethodInfo SysrootTryLockMethodInfo a signature where + overloadedMethod _ = sysrootTryLock + +#endif + +-- method Sysroot::unload +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_unload" ostree_sysroot_unload :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO () + +{- | +Release any resources such as file descriptors referring to the +root directory of this sysroot. Normally, those resources are +cleared by finalization, but in garbage collected languages that +may not be predictable. + +This undoes the effect of @ostree_sysroot_load()@. +-} +sysrootUnload :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Sysroot -} + -> m () +sysrootUnload self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_sysroot_unload self' + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data SysrootUnloadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootUnloadMethodInfo a signature where + overloadedMethod _ = sysrootUnload + +#endif + +-- method Sysroot::unlock +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_unlock" ostree_sysroot_unlock :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + IO () + +{- | +Clear the lock previously acquired with 'GI.OSTree.Objects.Sysroot.sysrootLock'. It +is safe to call this function if the lock has not been previously +acquired. +-} +sysrootUnlock :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) => + a + {- ^ /@self@/: Self -} + -> m () +sysrootUnlock self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + ostree_sysroot_unlock self' + touchManagedPtr self + return () + +#if ENABLE_OVERLOADING +data SysrootUnlockMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootUnlockMethodInfo a signature where + overloadedMethod _ = sysrootUnlock + +#endif + +-- method Sysroot::write_deployments +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployments", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "List of new deployments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_write_deployments" ostree_sysroot_write_deployments :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment)) -> -- new_deployments : TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Older version of 'GI.OSTree.Objects.Sysroot.sysrootWriteDeploymentsWithOptions'. This +version will perform post-deployment cleanup by default. +-} +sysrootWriteDeployments :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> [OSTree.Deployment.Deployment] + {- ^ /@newDeployments@/: List of new deployments -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootWriteDeployments self newDeployments cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + newDeployments' <- mapM unsafeManagedPtrCastPtr newDeployments + newDeployments'' <- packGPtrArray newDeployments' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_write_deployments self' newDeployments'' maybeCancellable + touchManagedPtr self + mapM_ touchManagedPtr newDeployments + whenJust cancellable touchManagedPtr + unrefPtrArray newDeployments'' + return () + ) (do + unrefPtrArray newDeployments'' + ) + +#if ENABLE_OVERLOADING +data SysrootWriteDeploymentsMethodInfo +instance (signature ~ ([OSTree.Deployment.Deployment] -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootWriteDeploymentsMethodInfo a signature where + overloadedMethod _ = sysrootWriteDeployments + +#endif + +-- method Sysroot::write_deployments_with_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployments", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "List of new deployments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opts", argType = TInterface (Name {namespace = "OSTree", name = "SysrootWriteDeploymentsOpts"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_write_deployments_with_options" ostree_sysroot_write_deployments_with_options :: + Ptr Sysroot -> -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment)) -> -- new_deployments : TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})) + Ptr OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts -> -- opts : TInterface (Name {namespace = "OSTree", name = "SysrootWriteDeploymentsOpts"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Assuming /@newDeployments@/ have already been deployed in place on disk via +'GI.OSTree.Objects.Sysroot.sysrootDeployTree', atomically update bootloader configuration. By +default, no post-transaction cleanup will be performed. You should invoke +'GI.OSTree.Objects.Sysroot.sysrootCleanup' at some point after the transaction, or specify +@do_postclean@ in /@opts@/. Skipping the post-transaction cleanup is useful +if for example you want to control pruning of the repository. +-} +sysrootWriteDeploymentsWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> [OSTree.Deployment.Deployment] + {- ^ /@newDeployments@/: List of new deployments -} + -> OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts + {- ^ /@opts@/: Options -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootWriteDeploymentsWithOptions self newDeployments opts cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + newDeployments' <- mapM unsafeManagedPtrCastPtr newDeployments + newDeployments'' <- packGPtrArray newDeployments' + opts' <- unsafeManagedPtrGetPtr opts + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_write_deployments_with_options self' newDeployments'' opts' maybeCancellable + touchManagedPtr self + mapM_ touchManagedPtr newDeployments + touchManagedPtr opts + whenJust cancellable touchManagedPtr + unrefPtrArray newDeployments'' + return () + ) (do + unrefPtrArray newDeployments'' + ) + +#if ENABLE_OVERLOADING +data SysrootWriteDeploymentsWithOptionsMethodInfo +instance (signature ~ ([OSTree.Deployment.Deployment] -> OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootWriteDeploymentsWithOptionsMethodInfo a signature where + overloadedMethod _ = sysrootWriteDeploymentsWithOptions + +#endif + +-- method Sysroot::write_origin_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "System root", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_write_origin_file" ostree_sysroot_write_origin_file :: + Ptr Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr OSTree.Deployment.Deployment -> -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"}) + Ptr GLib.KeyFile.KeyFile -> -- new_origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Immediately replace the origin file of the referenced /@deployment@/ +with the contents of /@newOrigin@/. If /@newOrigin@/ is 'Nothing', +this function will write the current origin of /@deployment@/. +-} +sysrootWriteOriginFile :: + (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@sysroot@/: System root -} + -> b + {- ^ /@deployment@/: Deployment -} + -> Maybe (GLib.KeyFile.KeyFile) + {- ^ /@newOrigin@/: Origin content -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootWriteOriginFile sysroot deployment newOrigin cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + deployment' <- unsafeManagedPtrCastPtr deployment + maybeNewOrigin <- case newOrigin of + Nothing -> return nullPtr + Just jNewOrigin -> do + jNewOrigin' <- unsafeManagedPtrGetPtr jNewOrigin + return jNewOrigin' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_write_origin_file sysroot' deployment' maybeNewOrigin maybeCancellable + touchManagedPtr sysroot + touchManagedPtr deployment + whenJust newOrigin touchManagedPtr + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootWriteOriginFileMethodInfo +instance (signature ~ (b -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootWriteOriginFileMethodInfo a signature where + overloadedMethod _ = sysrootWriteOriginFile + +#endif + +-- method Sysroot::get_deployment_origin_path +-- method type : MemberFunction +-- Args : [Arg {argCName = "deployment_path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_get_deployment_origin_path" ostree_sysroot_get_deployment_origin_path :: + Ptr Gio.File.File -> -- deployment_path : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ +-} +sysrootGetDeploymentOriginPath :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@deploymentPath@/: A deployment path -} + -> m Gio.File.File + {- ^ __Returns:__ Path to deployment origin file -} +sysrootGetDeploymentOriginPath deploymentPath = liftIO $ do + deploymentPath' <- unsafeManagedPtrCastPtr deploymentPath + result <- ostree_sysroot_get_deployment_origin_path deploymentPath' + checkUnexpectedReturnNULL "sysrootGetDeploymentOriginPath" result + result' <- (wrapObject Gio.File.File) result + touchManagedPtr deploymentPath + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/Sysroot.hs-boot b/GI/OSTree/Objects/Sysroot.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/Sysroot.hs-boot @@ -0,0 +1,146 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.Sysroot 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype Sysroot = Sysroot (ManagedPtr Sysroot) +instance GObject Sysroot where +class (GObject o, O.IsDescendantOf Sysroot o) => IsSysroot o +instance (GObject o, O.IsDescendantOf Sysroot o) => IsSysroot o +instance O.HasParentTypes Sysroot +#if ENABLE_OVERLOADING +data SysrootPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SysrootJournalMsgSignalInfo +#endif +#if ENABLE_OVERLOADING +data SysrootCleanupMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootCleanupPruneRepoMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootDeployTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootDeploymentSetKargsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootDeploymentSetMutableMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootDeploymentSetPinnedMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootDeploymentUnlockMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootEnsureInitializedMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetBootedDeploymentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetBootversionMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetDeploymentDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetDeploymentDirpathMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetDeploymentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetFdMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetMergeDeploymentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetRepoMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetStagedDeploymentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootGetSubbootversionMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootInitOsnameMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootLoadMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootLoadIfChangedMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootLockMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootLockAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootLockFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootOriginNewFromRefspecMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootPrepareCleanupMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootQueryDeploymentsForMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootRepoMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootSimpleWriteDeploymentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootStageTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootTryLockMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUnloadMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUnlockMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootWriteDeploymentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootWriteDeploymentsWithOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootWriteOriginFileMethodInfo +#endif diff --git a/GI/OSTree/Objects/SysrootUpgrader.hs b/GI/OSTree/Objects/SysrootUpgrader.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/SysrootUpgrader.hs @@ -0,0 +1,953 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Objects.SysrootUpgrader + ( + +-- * Exported types + SysrootUpgrader(..) , + IsSysrootUpgrader , + toSysrootUpgrader , + noSysrootUpgrader , + + + -- * Methods +-- ** checkTimestamps #method:checkTimestamps# + + sysrootUpgraderCheckTimestamps , + + +-- ** deploy #method:deploy# + +#if ENABLE_OVERLOADING + SysrootUpgraderDeployMethodInfo , +#endif + sysrootUpgraderDeploy , + + +-- ** dupOrigin #method:dupOrigin# + +#if ENABLE_OVERLOADING + SysrootUpgraderDupOriginMethodInfo , +#endif + sysrootUpgraderDupOrigin , + + +-- ** getOrigin #method:getOrigin# + +#if ENABLE_OVERLOADING + SysrootUpgraderGetOriginMethodInfo , +#endif + sysrootUpgraderGetOrigin , + + +-- ** getOriginDescription #method:getOriginDescription# + +#if ENABLE_OVERLOADING + SysrootUpgraderGetOriginDescriptionMethodInfo, +#endif + sysrootUpgraderGetOriginDescription , + + +-- ** new #method:new# + + sysrootUpgraderNew , + + +-- ** newForOs #method:newForOs# + + sysrootUpgraderNewForOs , + + +-- ** newForOsWithFlags #method:newForOsWithFlags# + + sysrootUpgraderNewForOsWithFlags , + + +-- ** pull #method:pull# + +#if ENABLE_OVERLOADING + SysrootUpgraderPullMethodInfo , +#endif + sysrootUpgraderPull , + + +-- ** pullOneDir #method:pullOneDir# + +#if ENABLE_OVERLOADING + SysrootUpgraderPullOneDirMethodInfo , +#endif + sysrootUpgraderPullOneDir , + + +-- ** setOrigin #method:setOrigin# + +#if ENABLE_OVERLOADING + SysrootUpgraderSetOriginMethodInfo , +#endif + sysrootUpgraderSetOrigin , + + + + + -- * Properties +-- ** flags #attr:flags# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SysrootUpgraderFlagsPropertyInfo , +#endif + constructSysrootUpgraderFlags , + getSysrootUpgraderFlags , +#if ENABLE_OVERLOADING + sysrootUpgraderFlags , +#endif + + +-- ** osname #attr:osname# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SysrootUpgraderOsnamePropertyInfo , +#endif + constructSysrootUpgraderOsname , + getSysrootUpgraderOsname , +#if ENABLE_OVERLOADING + sysrootUpgraderOsname , +#endif + + +-- ** sysroot #attr:sysroot# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SysrootUpgraderSysrootPropertyInfo , +#endif + constructSysrootUpgraderSysroot , + getSysrootUpgraderSysroot , +#if ENABLE_OVERLOADING + sysrootUpgraderSysroot , +#endif + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.KeyFile as GLib.KeyFile +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.Initable as Gio.Initable +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Objects.AsyncProgress as OSTree.AsyncProgress +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo +import {-# SOURCE #-} qualified GI.OSTree.Objects.Sysroot as OSTree.Sysroot + +-- | Memory-managed wrapper type. +newtype SysrootUpgrader = SysrootUpgrader (ManagedPtr SysrootUpgrader) +foreign import ccall "ostree_sysroot_upgrader_get_type" + c_ostree_sysroot_upgrader_get_type :: IO GType + +instance GObject SysrootUpgrader where + gobjectType = c_ostree_sysroot_upgrader_get_type + + +-- | Type class for types which can be safely cast to `SysrootUpgrader`, for instance with `toSysrootUpgrader`. +class (GObject o, O.IsDescendantOf SysrootUpgrader o) => IsSysrootUpgrader o +instance (GObject o, O.IsDescendantOf SysrootUpgrader o) => IsSysrootUpgrader o + +instance O.HasParentTypes SysrootUpgrader +type instance O.ParentTypes SysrootUpgrader = '[GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `SysrootUpgrader`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSysrootUpgrader :: (MonadIO m, IsSysrootUpgrader o) => o -> m SysrootUpgrader +toSysrootUpgrader = liftIO . unsafeCastTo SysrootUpgrader + +-- | A convenience alias for `Nothing` :: `Maybe` `SysrootUpgrader`. +noSysrootUpgrader :: Maybe SysrootUpgrader +noSysrootUpgrader = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSysrootUpgraderMethod (t :: Symbol) (o :: *) :: * where + ResolveSysrootUpgraderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSysrootUpgraderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSysrootUpgraderMethod "deploy" o = SysrootUpgraderDeployMethodInfo + ResolveSysrootUpgraderMethod "dupOrigin" o = SysrootUpgraderDupOriginMethodInfo + ResolveSysrootUpgraderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSysrootUpgraderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSysrootUpgraderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSysrootUpgraderMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveSysrootUpgraderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSysrootUpgraderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSysrootUpgraderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSysrootUpgraderMethod "pull" o = SysrootUpgraderPullMethodInfo + ResolveSysrootUpgraderMethod "pullOneDir" o = SysrootUpgraderPullOneDirMethodInfo + ResolveSysrootUpgraderMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSysrootUpgraderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSysrootUpgraderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSysrootUpgraderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSysrootUpgraderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSysrootUpgraderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSysrootUpgraderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSysrootUpgraderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSysrootUpgraderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSysrootUpgraderMethod "getOrigin" o = SysrootUpgraderGetOriginMethodInfo + ResolveSysrootUpgraderMethod "getOriginDescription" o = SysrootUpgraderGetOriginDescriptionMethodInfo + ResolveSysrootUpgraderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSysrootUpgraderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSysrootUpgraderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSysrootUpgraderMethod "setOrigin" o = SysrootUpgraderSetOriginMethodInfo + ResolveSysrootUpgraderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSysrootUpgraderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSysrootUpgraderMethod t SysrootUpgrader, O.MethodInfo info SysrootUpgrader p) => OL.IsLabel t (SysrootUpgrader -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "flags" + -- Type: TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderFlags"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sysrootUpgrader #flags +@ +-} +getSysrootUpgraderFlags :: (MonadIO m, IsSysrootUpgrader o) => o -> m [OSTree.Flags.SysrootUpgraderFlags] +getSysrootUpgraderFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" + +{- | +Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSysrootUpgraderFlags :: (IsSysrootUpgrader o) => [OSTree.Flags.SysrootUpgraderFlags] -> IO (GValueConstruct o) +constructSysrootUpgraderFlags val = B.Properties.constructObjectPropertyFlags "flags" val + +#if ENABLE_OVERLOADING +data SysrootUpgraderFlagsPropertyInfo +instance AttrInfo SysrootUpgraderFlagsPropertyInfo where + type AttrAllowedOps SysrootUpgraderFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SysrootUpgraderFlagsPropertyInfo = (~) [OSTree.Flags.SysrootUpgraderFlags] + type AttrBaseTypeConstraint SysrootUpgraderFlagsPropertyInfo = IsSysrootUpgrader + type AttrGetType SysrootUpgraderFlagsPropertyInfo = [OSTree.Flags.SysrootUpgraderFlags] + type AttrLabel SysrootUpgraderFlagsPropertyInfo = "flags" + type AttrOrigin SysrootUpgraderFlagsPropertyInfo = SysrootUpgrader + attrGet _ = getSysrootUpgraderFlags + attrSet _ = undefined + attrConstruct _ = constructSysrootUpgraderFlags + attrClear _ = undefined +#endif + +-- VVV Prop "osname" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@osname@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sysrootUpgrader #osname +@ +-} +getSysrootUpgraderOsname :: (MonadIO m, IsSysrootUpgrader o) => o -> m (Maybe T.Text) +getSysrootUpgraderOsname obj = liftIO $ B.Properties.getObjectPropertyString obj "osname" + +{- | +Construct a `GValueConstruct` with valid value for the “@osname@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSysrootUpgraderOsname :: (IsSysrootUpgrader o) => T.Text -> IO (GValueConstruct o) +constructSysrootUpgraderOsname val = B.Properties.constructObjectPropertyString "osname" (Just val) + +#if ENABLE_OVERLOADING +data SysrootUpgraderOsnamePropertyInfo +instance AttrInfo SysrootUpgraderOsnamePropertyInfo where + type AttrAllowedOps SysrootUpgraderOsnamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SysrootUpgraderOsnamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SysrootUpgraderOsnamePropertyInfo = IsSysrootUpgrader + type AttrGetType SysrootUpgraderOsnamePropertyInfo = (Maybe T.Text) + type AttrLabel SysrootUpgraderOsnamePropertyInfo = "osname" + type AttrOrigin SysrootUpgraderOsnamePropertyInfo = SysrootUpgrader + attrGet _ = getSysrootUpgraderOsname + attrSet _ = undefined + attrConstruct _ = constructSysrootUpgraderOsname + attrClear _ = undefined +#endif + +-- VVV Prop "sysroot" + -- Type: TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@sysroot@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sysrootUpgrader #sysroot +@ +-} +getSysrootUpgraderSysroot :: (MonadIO m, IsSysrootUpgrader o) => o -> m (Maybe OSTree.Sysroot.Sysroot) +getSysrootUpgraderSysroot obj = liftIO $ B.Properties.getObjectPropertyObject obj "sysroot" OSTree.Sysroot.Sysroot + +{- | +Construct a `GValueConstruct` with valid value for the “@sysroot@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSysrootUpgraderSysroot :: (IsSysrootUpgrader o, OSTree.Sysroot.IsSysroot a) => a -> IO (GValueConstruct o) +constructSysrootUpgraderSysroot val = B.Properties.constructObjectPropertyObject "sysroot" (Just val) + +#if ENABLE_OVERLOADING +data SysrootUpgraderSysrootPropertyInfo +instance AttrInfo SysrootUpgraderSysrootPropertyInfo where + type AttrAllowedOps SysrootUpgraderSysrootPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SysrootUpgraderSysrootPropertyInfo = OSTree.Sysroot.IsSysroot + type AttrBaseTypeConstraint SysrootUpgraderSysrootPropertyInfo = IsSysrootUpgrader + type AttrGetType SysrootUpgraderSysrootPropertyInfo = (Maybe OSTree.Sysroot.Sysroot) + type AttrLabel SysrootUpgraderSysrootPropertyInfo = "sysroot" + type AttrOrigin SysrootUpgraderSysrootPropertyInfo = SysrootUpgrader + attrGet _ = getSysrootUpgraderSysroot + attrSet _ = undefined + attrConstruct _ = constructSysrootUpgraderSysroot + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SysrootUpgrader +type instance O.AttributeList SysrootUpgrader = SysrootUpgraderAttributeList +type SysrootUpgraderAttributeList = ('[ '("flags", SysrootUpgraderFlagsPropertyInfo), '("osname", SysrootUpgraderOsnamePropertyInfo), '("sysroot", SysrootUpgraderSysrootPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +sysrootUpgraderFlags :: AttrLabelProxy "flags" +sysrootUpgraderFlags = AttrLabelProxy + +sysrootUpgraderOsname :: AttrLabelProxy "osname" +sysrootUpgraderOsname = AttrLabelProxy + +sysrootUpgraderSysroot :: AttrLabelProxy "sysroot" +sysrootUpgraderSysroot = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SysrootUpgrader = SysrootUpgraderSignalList +type SysrootUpgraderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SysrootUpgrader::new +-- method type : Constructor +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeSysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_new" ostree_sysroot_upgrader_new :: + Ptr OSTree.Sysroot.Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr SysrootUpgrader) + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderNew :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@sysroot@/: An 'GI.OSTree.Objects.Sysroot.Sysroot' -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m SysrootUpgrader + {- ^ __Returns:__ An upgrader /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderNew sysroot cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_sysroot_upgrader_new sysroot' maybeCancellable + checkUnexpectedReturnNULL "sysrootUpgraderNew" result + result' <- (wrapObject SysrootUpgrader) result + touchManagedPtr sysroot + whenJust cancellable touchManagedPtr + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method SysrootUpgrader::new_for_os +-- method type : Constructor +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeSysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Operating system name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_new_for_os" ostree_sysroot_upgrader_new_for_os :: + Ptr OSTree.Sysroot.Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr SysrootUpgrader) + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderNewForOs :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@sysroot@/: An 'GI.OSTree.Objects.Sysroot.Sysroot' -} + -> Maybe (T.Text) + {- ^ /@osname@/: Operating system name -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m SysrootUpgrader + {- ^ __Returns:__ An upgrader /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderNewForOs sysroot osname cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_sysroot_upgrader_new_for_os sysroot' maybeOsname maybeCancellable + checkUnexpectedReturnNULL "sysrootUpgraderNewForOs" result + result' <- (wrapObject SysrootUpgrader) result + touchManagedPtr sysroot + whenJust cancellable touchManagedPtr + freeMem maybeOsname + return result' + ) (do + freeMem maybeOsname + ) + +#if ENABLE_OVERLOADING +#endif + +-- method SysrootUpgrader::new_for_os_with_flags +-- method type : Constructor +-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeSysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Operating system name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_new_for_os_with_flags" ostree_sysroot_upgrader_new_for_os_with_flags :: + Ptr OSTree.Sysroot.Sysroot -> -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"}) + CString -> -- osname : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderFlags"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr SysrootUpgrader) + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderNewForOsWithFlags :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@sysroot@/: An 'GI.OSTree.Objects.Sysroot.Sysroot' -} + -> Maybe (T.Text) + {- ^ /@osname@/: Operating system name -} + -> [OSTree.Flags.SysrootUpgraderFlags] + {- ^ /@flags@/: Flags -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m SysrootUpgrader + {- ^ __Returns:__ An upgrader /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderNewForOsWithFlags sysroot osname flags cancellable = liftIO $ do + sysroot' <- unsafeManagedPtrCastPtr sysroot + maybeOsname <- case osname of + Nothing -> return nullPtr + Just jOsname -> do + jOsname' <- textToCString jOsname + return jOsname' + let flags' = gflagsToWord flags + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_sysroot_upgrader_new_for_os_with_flags sysroot' maybeOsname flags' maybeCancellable + checkUnexpectedReturnNULL "sysrootUpgraderNewForOsWithFlags" result + result' <- (wrapObject SysrootUpgrader) result + touchManagedPtr sysroot + whenJust cancellable touchManagedPtr + freeMem maybeOsname + return result' + ) (do + freeMem maybeOsname + ) + +#if ENABLE_OVERLOADING +#endif + +-- method SysrootUpgrader::deploy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_deploy" ostree_sysroot_upgrader_deploy :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write the new deployment to disk, perform a configuration merge +with \/etc, and update the bootloader configuration. +-} +sysrootUpgraderDeploy :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Self -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderDeploy self cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_upgrader_deploy self' maybeCancellable + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootUpgraderDeployMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSysrootUpgrader a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootUpgraderDeployMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderDeploy + +#endif + +-- method SysrootUpgrader::dup_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_dup_origin" ostree_sysroot_upgrader_dup_origin :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderDupOrigin :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a) => + a + {- ^ /@self@/: Sysroot -} + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ A copy of the origin file, or 'Nothing' if unknown -} +sysrootUpgraderDupOrigin self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_upgrader_dup_origin self' + checkUnexpectedReturnNULL "sysrootUpgraderDupOrigin" result + result' <- (wrapBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootUpgraderDupOriginMethodInfo +instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsSysrootUpgrader a) => O.MethodInfo SysrootUpgraderDupOriginMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderDupOrigin + +#endif + +-- method SysrootUpgrader::get_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_get_origin" ostree_sysroot_upgrader_get_origin :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + IO (Ptr GLib.KeyFile.KeyFile) + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderGetOrigin :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a) => + a + {- ^ /@self@/: Sysroot -} + -> m GLib.KeyFile.KeyFile + {- ^ __Returns:__ The origin file, or 'Nothing' if unknown -} +sysrootUpgraderGetOrigin self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_upgrader_get_origin self' + checkUnexpectedReturnNULL "sysrootUpgraderGetOrigin" result + result' <- (newBoxed GLib.KeyFile.KeyFile) result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootUpgraderGetOriginMethodInfo +instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsSysrootUpgrader a) => O.MethodInfo SysrootUpgraderGetOriginMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderGetOrigin + +#endif + +-- method SysrootUpgrader::get_origin_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Upgrader", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_get_origin_description" ostree_sysroot_upgrader_get_origin_description :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +sysrootUpgraderGetOriginDescription :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a) => + a + {- ^ /@self@/: Upgrader -} + -> m T.Text + {- ^ __Returns:__ A one-line descriptive summary of the origin, or 'Nothing' if unknown -} +sysrootUpgraderGetOriginDescription self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- ostree_sysroot_upgrader_get_origin_description self' + checkUnexpectedReturnNULL "sysrootUpgraderGetOriginDescription" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + return result' + +#if ENABLE_OVERLOADING +data SysrootUpgraderGetOriginDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSysrootUpgrader a) => O.MethodInfo SysrootUpgraderGetOriginDescriptionMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderGetOriginDescription + +#endif + +-- method SysrootUpgrader::pull +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Upgrader", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling pull behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upgrader_flags", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling upgrader behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_changed", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the origin changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_pull" ostree_sysroot_upgrader_pull :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}) + CUInt -> -- upgrader_flags : TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderPullFlags"}) + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr CInt -> -- out_changed : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Perform a pull from the origin. First check if the ref has +changed, if so download the linked objects, and store the updated +ref locally. Then /@outChanged@/ will be 'True'. + +If the origin remote is unchanged, /@outChanged@/ will be set to +'False'. +-} +sysrootUpgraderPull :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Upgrader -} + -> [OSTree.Flags.RepoPullFlags] + {- ^ /@flags@/: Flags controlling pull behavior -} + -> [OSTree.Flags.SysrootUpgraderPullFlags] + {- ^ /@upgraderFlags@/: Flags controlling upgrader behavior -} + -> Maybe (b) + {- ^ /@progress@/: Progress -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderPull self flags upgraderFlags progress cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let flags' = gflagsToWord flags + let upgraderFlags' = gflagsToWord upgraderFlags + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + outChanged <- allocMem :: IO (Ptr CInt) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_upgrader_pull self' flags' upgraderFlags' maybeProgress outChanged maybeCancellable + outChanged' <- peek outChanged + let outChanged'' = (/= 0) outChanged' + touchManagedPtr self + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem outChanged + return outChanged'' + ) (do + freeMem outChanged + ) + +#if ENABLE_OVERLOADING +data SysrootUpgraderPullMethodInfo +instance (signature ~ ([OSTree.Flags.RepoPullFlags] -> [OSTree.Flags.SysrootUpgraderPullFlags] -> Maybe (b) -> Maybe (c) -> m (Bool)), MonadIO m, IsSysrootUpgrader a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootUpgraderPullMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderPull + +#endif + +-- method SysrootUpgrader::pull_one_dir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Upgrader", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir_to_pull", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Subdirectory path (should include a leading /)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling pull behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upgrader_flags", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderPullFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling upgrader behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Progress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_changed", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the origin changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_pull_one_dir" ostree_sysroot_upgrader_pull_one_dir :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + CString -> -- dir_to_pull : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"}) + CUInt -> -- upgrader_flags : TInterface (Name {namespace = "OSTree", name = "SysrootUpgraderPullFlags"}) + Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"}) + Ptr CInt -> -- out_changed : TBasicType TBoolean + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Like 'GI.OSTree.Objects.SysrootUpgrader.sysrootUpgraderPull', but allows retrieving just a +subpath of the tree. This can be used to download metadata files +from inside the tree such as package databases. +-} +sysrootUpgraderPullOneDir :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@self@/: Upgrader -} + -> T.Text + {- ^ /@dirToPull@/: Subdirectory path (should include a leading \/) -} + -> [OSTree.Flags.RepoPullFlags] + {- ^ /@flags@/: Flags controlling pull behavior -} + -> [OSTree.Flags.SysrootUpgraderPullFlags] + {- ^ /@upgraderFlags@/: Flags controlling upgrader behavior -} + -> Maybe (b) + {- ^ /@progress@/: Progress -} + -> Maybe (c) + {- ^ /@cancellable@/: Cancellable -} + -> m (Bool) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderPullOneDir self dirToPull flags upgraderFlags progress cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + dirToPull' <- textToCString dirToPull + let flags' = gflagsToWord flags + let upgraderFlags' = gflagsToWord upgraderFlags + maybeProgress <- case progress of + Nothing -> return nullPtr + Just jProgress -> do + jProgress' <- unsafeManagedPtrCastPtr jProgress + return jProgress' + outChanged <- allocMem :: IO (Ptr CInt) + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_upgrader_pull_one_dir self' dirToPull' flags' upgraderFlags' maybeProgress outChanged maybeCancellable + outChanged' <- peek outChanged + let outChanged'' = (/= 0) outChanged' + touchManagedPtr self + whenJust progress touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem dirToPull' + freeMem outChanged + return outChanged'' + ) (do + freeMem dirToPull' + freeMem outChanged + ) + +#if ENABLE_OVERLOADING +data SysrootUpgraderPullOneDirMethodInfo +instance (signature ~ (T.Text -> [OSTree.Flags.RepoPullFlags] -> [OSTree.Flags.SysrootUpgraderPullFlags] -> Maybe (b) -> Maybe (c) -> m (Bool)), MonadIO m, IsSysrootUpgrader a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootUpgraderPullOneDirMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderPullOneDir + +#endif + +-- method SysrootUpgrader::set_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The new origin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_set_origin" ostree_sysroot_upgrader_set_origin :: + Ptr SysrootUpgrader -> -- self : TInterface (Name {namespace = "OSTree", name = "SysrootUpgrader"}) + Ptr GLib.KeyFile.KeyFile -> -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Replace the origin with /@origin@/. +-} +sysrootUpgraderSetOrigin :: + (B.CallStack.HasCallStack, MonadIO m, IsSysrootUpgrader a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@self@/: Sysroot -} + -> Maybe (GLib.KeyFile.KeyFile) + {- ^ /@origin@/: The new origin -} + -> Maybe (b) + {- ^ /@cancellable@/: Cancellable -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderSetOrigin self origin cancellable = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeOrigin <- case origin of + Nothing -> return nullPtr + Just jOrigin -> do + jOrigin' <- unsafeManagedPtrGetPtr jOrigin + return jOrigin' + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + _ <- propagateGError $ ostree_sysroot_upgrader_set_origin self' maybeOrigin maybeCancellable + touchManagedPtr self + whenJust origin touchManagedPtr + whenJust cancellable touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SysrootUpgraderSetOriginMethodInfo +instance (signature ~ (Maybe (GLib.KeyFile.KeyFile) -> Maybe (b) -> m ()), MonadIO m, IsSysrootUpgrader a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootUpgraderSetOriginMethodInfo a signature where + overloadedMethod _ = sysrootUpgraderSetOrigin + +#endif + +-- method SysrootUpgrader::check_timestamps +-- method type : MemberFunction +-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from_rev", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "From revision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_rev", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "To revision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_sysroot_upgrader_check_timestamps" ostree_sysroot_upgrader_check_timestamps :: + Ptr OSTree.Repo.Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + CString -> -- from_rev : TBasicType TUTF8 + CString -> -- to_rev : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check that the timestamp on /@toRev@/ is equal to or newer than +/@fromRev@/. This protects systems against man-in-the-middle +attackers which provide a client with an older commit. +-} +sysrootUpgraderCheckTimestamps :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + a + {- ^ /@repo@/: Repo -} + -> T.Text + {- ^ /@fromRev@/: From revision -} + -> T.Text + {- ^ /@toRev@/: To revision -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +sysrootUpgraderCheckTimestamps repo fromRev toRev = liftIO $ do + repo' <- unsafeManagedPtrCastPtr repo + fromRev' <- textToCString fromRev + toRev' <- textToCString toRev + onException (do + _ <- propagateGError $ ostree_sysroot_upgrader_check_timestamps repo' fromRev' toRev' + touchManagedPtr repo + freeMem fromRev' + freeMem toRev' + return () + ) (do + freeMem fromRev' + freeMem toRev' + ) + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/OSTree/Objects/SysrootUpgrader.hs-boot b/GI/OSTree/Objects/SysrootUpgrader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Objects/SysrootUpgrader.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Objects.SysrootUpgrader 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype SysrootUpgrader = SysrootUpgrader (ManagedPtr SysrootUpgrader) +instance GObject SysrootUpgrader where +class (GObject o, O.IsDescendantOf SysrootUpgrader o) => IsSysrootUpgrader o +instance (GObject o, O.IsDescendantOf SysrootUpgrader o) => IsSysrootUpgrader o +instance O.HasParentTypes SysrootUpgrader +#if ENABLE_OVERLOADING +data SysrootUpgraderFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderOsnamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderSysrootPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderDeployMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderDupOriginMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderGetOriginMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderGetOriginDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderPullMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderPullOneDirMethodInfo +#endif +#if ENABLE_OVERLOADING +data SysrootUpgraderSetOriginMethodInfo +#endif diff --git a/GI/OSTree/Structs.hs b/GI/OSTree/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs.hs @@ -0,0 +1,93 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs + ( module GI.OSTree.Structs.Bootloader , + module GI.OSTree.Structs.BootloaderGrub2, + module GI.OSTree.Structs.BootloaderInterface, + module GI.OSTree.Structs.BootloaderSyslinux, + module GI.OSTree.Structs.BootloaderUboot, + module GI.OSTree.Structs.CmdPrivateVTable, + module GI.OSTree.Structs.CollectionRef , + module GI.OSTree.Structs.DiffDirsOptions, + module GI.OSTree.Structs.DiffItem , + module GI.OSTree.Structs.GpgVerifier , + module GI.OSTree.Structs.LibarchiveInputStream, + module GI.OSTree.Structs.LzmaCompressor , + module GI.OSTree.Structs.LzmaDecompressor, + module GI.OSTree.Structs.MutableTreeIter, + module GI.OSTree.Structs.Remote , + module GI.OSTree.Structs.RepoCheckoutAtOptions, + module GI.OSTree.Structs.RepoCommitModifier, + module GI.OSTree.Structs.RepoCommitTraverseIter, + module GI.OSTree.Structs.RepoDevInoCache, + module GI.OSTree.Structs.RepoFileEnumerator, + module GI.OSTree.Structs.RepoFinderResult, + module GI.OSTree.Structs.RepoPruneOptions, + module GI.OSTree.Structs.RepoTransactionStats, + module GI.OSTree.Structs.RollsumMatches , + module GI.OSTree.Structs.SysrootWriteDeploymentsOpts, + module GI.OSTree.Structs.TlsCertInteraction, + module GI.OSTree.Structs.TlsCertInteractionClass, + + + ) where + +import GI.OSTree.Structs.Bootloader +import GI.OSTree.Structs.BootloaderGrub2 +import GI.OSTree.Structs.BootloaderInterface +import GI.OSTree.Structs.BootloaderSyslinux +import GI.OSTree.Structs.BootloaderUboot +import GI.OSTree.Structs.CmdPrivateVTable +import GI.OSTree.Structs.CollectionRef +import GI.OSTree.Structs.DiffDirsOptions +import GI.OSTree.Structs.DiffItem +import GI.OSTree.Structs.GpgVerifier +import GI.OSTree.Structs.LibarchiveInputStream +import GI.OSTree.Structs.LzmaCompressor +import GI.OSTree.Structs.LzmaDecompressor +import GI.OSTree.Structs.MutableTreeIter +import GI.OSTree.Structs.Remote +import GI.OSTree.Structs.RepoCheckoutAtOptions +import GI.OSTree.Structs.RepoCommitModifier +import GI.OSTree.Structs.RepoCommitTraverseIter +import GI.OSTree.Structs.RepoDevInoCache +import GI.OSTree.Structs.RepoFileEnumerator +import GI.OSTree.Structs.RepoFinderResult +import GI.OSTree.Structs.RepoPruneOptions +import GI.OSTree.Structs.RepoTransactionStats +import GI.OSTree.Structs.RollsumMatches +import GI.OSTree.Structs.SysrootWriteDeploymentsOpts +import GI.OSTree.Structs.TlsCertInteraction +import GI.OSTree.Structs.TlsCertInteractionClass + +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.ManagedPtr as B.ManagedPtr +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.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 + + + diff --git a/GI/OSTree/Structs/Bootloader.hs b/GI/OSTree/Structs/Bootloader.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/Bootloader.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.Bootloader + ( + +-- * Exported types + Bootloader(..) , + noBootloader , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype Bootloader = Bootloader (ManagedPtr Bootloader) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr Bootloader where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `Bootloader`. +noBootloader :: Maybe Bootloader +noBootloader = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Bootloader +type instance O.AttributeList Bootloader = BootloaderAttributeList +type BootloaderAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveBootloaderMethod (t :: Symbol) (o :: *) :: * where + ResolveBootloaderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootloaderMethod t Bootloader, O.MethodInfo info Bootloader p) => OL.IsLabel t (Bootloader -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/Bootloader.hs-boot b/GI/OSTree/Structs/Bootloader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/Bootloader.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.Bootloader 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype Bootloader = Bootloader (ManagedPtr Bootloader) +instance WrappedPtr Bootloader where diff --git a/GI/OSTree/Structs/BootloaderGrub2.hs b/GI/OSTree/Structs/BootloaderGrub2.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderGrub2.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.BootloaderGrub2 + ( + +-- * Exported types + BootloaderGrub2(..) , + noBootloaderGrub2 , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype BootloaderGrub2 = BootloaderGrub2 (ManagedPtr BootloaderGrub2) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr BootloaderGrub2 where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `BootloaderGrub2`. +noBootloaderGrub2 :: Maybe BootloaderGrub2 +noBootloaderGrub2 = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BootloaderGrub2 +type instance O.AttributeList BootloaderGrub2 = BootloaderGrub2AttributeList +type BootloaderGrub2AttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveBootloaderGrub2Method (t :: Symbol) (o :: *) :: * where + ResolveBootloaderGrub2Method l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootloaderGrub2Method t BootloaderGrub2, O.MethodInfo info BootloaderGrub2 p) => OL.IsLabel t (BootloaderGrub2 -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/BootloaderGrub2.hs-boot b/GI/OSTree/Structs/BootloaderGrub2.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderGrub2.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.BootloaderGrub2 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype BootloaderGrub2 = BootloaderGrub2 (ManagedPtr BootloaderGrub2) +instance WrappedPtr BootloaderGrub2 where diff --git a/GI/OSTree/Structs/BootloaderInterface.hs b/GI/OSTree/Structs/BootloaderInterface.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderInterface.hs @@ -0,0 +1,349 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.BootloaderInterface + ( + +-- * Exported types + BootloaderInterface(..) , + newZeroBootloaderInterface , + noBootloaderInterface , + + + -- * Properties +-- ** gIface #attr:gIface# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + bootloaderInterface_gIface , +#endif + getBootloaderInterfaceGIface , + + +-- ** getName #attr:getName# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + bootloaderInterface_getName , +#endif + clearBootloaderInterfaceGetName , + getBootloaderInterfaceGetName , + setBootloaderInterfaceGetName , + + +-- ** isAtomic #attr:isAtomic# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + bootloaderInterface_isAtomic , +#endif + clearBootloaderInterfaceIsAtomic , + getBootloaderInterfaceIsAtomic , + setBootloaderInterfaceIsAtomic , + + +-- ** query #attr:query# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + bootloaderInterface_query , +#endif + clearBootloaderInterfaceQuery , + getBootloaderInterfaceQuery , + setBootloaderInterfaceQuery , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GObject.Structs.TypeInterface as GObject.TypeInterface +import qualified GI.OSTree.Callbacks as OSTree.Callbacks + +-- | Memory-managed wrapper type. +newtype BootloaderInterface = BootloaderInterface (ManagedPtr BootloaderInterface) +instance WrappedPtr BootloaderInterface where + wrappedPtrCalloc = callocBytes 48 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr BootloaderInterface) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `BootloaderInterface` struct initialized to zero. +newZeroBootloaderInterface :: MonadIO m => m BootloaderInterface +newZeroBootloaderInterface = liftIO $ wrappedPtrCalloc >>= wrapPtr BootloaderInterface + +instance tag ~ 'AttrSet => Constructible BootloaderInterface tag where + new _ attrs = do + o <- newZeroBootloaderInterface + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `BootloaderInterface`. +noBootloaderInterface :: Maybe BootloaderInterface +noBootloaderInterface = Nothing + +{- | +Get the value of the “@g_iface@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' bootloaderInterface #gIface +@ +-} +getBootloaderInterfaceGIface :: MonadIO m => BootloaderInterface -> m GObject.TypeInterface.TypeInterface +getBootloaderInterfaceGIface s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr GObject.TypeInterface.TypeInterface) + val' <- (newPtr GObject.TypeInterface.TypeInterface) val + return val' + +#if ENABLE_OVERLOADING +data BootloaderInterfaceGIfaceFieldInfo +instance AttrInfo BootloaderInterfaceGIfaceFieldInfo where + type AttrAllowedOps BootloaderInterfaceGIfaceFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint BootloaderInterfaceGIfaceFieldInfo = (~) (Ptr GObject.TypeInterface.TypeInterface) + type AttrBaseTypeConstraint BootloaderInterfaceGIfaceFieldInfo = (~) BootloaderInterface + type AttrGetType BootloaderInterfaceGIfaceFieldInfo = GObject.TypeInterface.TypeInterface + type AttrLabel BootloaderInterfaceGIfaceFieldInfo = "g_iface" + type AttrOrigin BootloaderInterfaceGIfaceFieldInfo = BootloaderInterface + attrGet _ = getBootloaderInterfaceGIface + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +bootloaderInterface_gIface :: AttrLabelProxy "gIface" +bootloaderInterface_gIface = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@query@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' bootloaderInterface #query +@ +-} +getBootloaderInterfaceQuery :: MonadIO m => BootloaderInterface -> m (Maybe OSTree.Callbacks.BootloaderInterfaceQueryFieldCallback) +getBootloaderInterfaceQuery s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (FunPtr OSTree.Callbacks.C_BootloaderInterfaceQueryFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_BootloaderInterfaceQueryFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@query@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' bootloaderInterface [ #query 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBootloaderInterfaceQuery :: MonadIO m => BootloaderInterface -> FunPtr OSTree.Callbacks.C_BootloaderInterfaceQueryFieldCallback -> m () +setBootloaderInterfaceQuery s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceQueryFieldCallback) + +{- | +Set the value of the “@query@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #query +@ +-} +clearBootloaderInterfaceQuery :: MonadIO m => BootloaderInterface -> m () +clearBootloaderInterfaceQuery s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceQueryFieldCallback) + +#if ENABLE_OVERLOADING +data BootloaderInterfaceQueryFieldInfo +instance AttrInfo BootloaderInterfaceQueryFieldInfo where + type AttrAllowedOps BootloaderInterfaceQueryFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BootloaderInterfaceQueryFieldInfo = (~) (FunPtr OSTree.Callbacks.C_BootloaderInterfaceQueryFieldCallback) + type AttrBaseTypeConstraint BootloaderInterfaceQueryFieldInfo = (~) BootloaderInterface + type AttrGetType BootloaderInterfaceQueryFieldInfo = Maybe OSTree.Callbacks.BootloaderInterfaceQueryFieldCallback + type AttrLabel BootloaderInterfaceQueryFieldInfo = "query" + type AttrOrigin BootloaderInterfaceQueryFieldInfo = BootloaderInterface + attrGet _ = getBootloaderInterfaceQuery + attrSet _ = setBootloaderInterfaceQuery + attrConstruct = undefined + attrClear _ = clearBootloaderInterfaceQuery + +bootloaderInterface_query :: AttrLabelProxy "query" +bootloaderInterface_query = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@get_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' bootloaderInterface #getName +@ +-} +getBootloaderInterfaceGetName :: MonadIO m => BootloaderInterface -> m (Maybe OSTree.Callbacks.BootloaderInterfaceGetNameFieldCallback) +getBootloaderInterfaceGetName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (FunPtr OSTree.Callbacks.C_BootloaderInterfaceGetNameFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_BootloaderInterfaceGetNameFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@get_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' bootloaderInterface [ #getName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBootloaderInterfaceGetName :: MonadIO m => BootloaderInterface -> FunPtr OSTree.Callbacks.C_BootloaderInterfaceGetNameFieldCallback -> m () +setBootloaderInterfaceGetName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceGetNameFieldCallback) + +{- | +Set the value of the “@get_name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #getName +@ +-} +clearBootloaderInterfaceGetName :: MonadIO m => BootloaderInterface -> m () +clearBootloaderInterfaceGetName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceGetNameFieldCallback) + +#if ENABLE_OVERLOADING +data BootloaderInterfaceGetNameFieldInfo +instance AttrInfo BootloaderInterfaceGetNameFieldInfo where + type AttrAllowedOps BootloaderInterfaceGetNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BootloaderInterfaceGetNameFieldInfo = (~) (FunPtr OSTree.Callbacks.C_BootloaderInterfaceGetNameFieldCallback) + type AttrBaseTypeConstraint BootloaderInterfaceGetNameFieldInfo = (~) BootloaderInterface + type AttrGetType BootloaderInterfaceGetNameFieldInfo = Maybe OSTree.Callbacks.BootloaderInterfaceGetNameFieldCallback + type AttrLabel BootloaderInterfaceGetNameFieldInfo = "get_name" + type AttrOrigin BootloaderInterfaceGetNameFieldInfo = BootloaderInterface + attrGet _ = getBootloaderInterfaceGetName + attrSet _ = setBootloaderInterfaceGetName + attrConstruct = undefined + attrClear _ = clearBootloaderInterfaceGetName + +bootloaderInterface_getName :: AttrLabelProxy "getName" +bootloaderInterface_getName = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@is_atomic@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' bootloaderInterface #isAtomic +@ +-} +getBootloaderInterfaceIsAtomic :: MonadIO m => BootloaderInterface -> m (Maybe OSTree.Callbacks.BootloaderInterfaceIsAtomicFieldCallback) +getBootloaderInterfaceIsAtomic s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO (FunPtr OSTree.Callbacks.C_BootloaderInterfaceIsAtomicFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_BootloaderInterfaceIsAtomicFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@is_atomic@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' bootloaderInterface [ #isAtomic 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBootloaderInterfaceIsAtomic :: MonadIO m => BootloaderInterface -> FunPtr OSTree.Callbacks.C_BootloaderInterfaceIsAtomicFieldCallback -> m () +setBootloaderInterfaceIsAtomic s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceIsAtomicFieldCallback) + +{- | +Set the value of the “@is_atomic@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #isAtomic +@ +-} +clearBootloaderInterfaceIsAtomic :: MonadIO m => BootloaderInterface -> m () +clearBootloaderInterfaceIsAtomic s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_BootloaderInterfaceIsAtomicFieldCallback) + +#if ENABLE_OVERLOADING +data BootloaderInterfaceIsAtomicFieldInfo +instance AttrInfo BootloaderInterfaceIsAtomicFieldInfo where + type AttrAllowedOps BootloaderInterfaceIsAtomicFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BootloaderInterfaceIsAtomicFieldInfo = (~) (FunPtr OSTree.Callbacks.C_BootloaderInterfaceIsAtomicFieldCallback) + type AttrBaseTypeConstraint BootloaderInterfaceIsAtomicFieldInfo = (~) BootloaderInterface + type AttrGetType BootloaderInterfaceIsAtomicFieldInfo = Maybe OSTree.Callbacks.BootloaderInterfaceIsAtomicFieldCallback + type AttrLabel BootloaderInterfaceIsAtomicFieldInfo = "is_atomic" + type AttrOrigin BootloaderInterfaceIsAtomicFieldInfo = BootloaderInterface + attrGet _ = getBootloaderInterfaceIsAtomic + attrSet _ = setBootloaderInterfaceIsAtomic + attrConstruct = undefined + attrClear _ = clearBootloaderInterfaceIsAtomic + +bootloaderInterface_isAtomic :: AttrLabelProxy "isAtomic" +bootloaderInterface_isAtomic = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BootloaderInterface +type instance O.AttributeList BootloaderInterface = BootloaderInterfaceAttributeList +type BootloaderInterfaceAttributeList = ('[ '("gIface", BootloaderInterfaceGIfaceFieldInfo), '("query", BootloaderInterfaceQueryFieldInfo), '("getName", BootloaderInterfaceGetNameFieldInfo), '("isAtomic", BootloaderInterfaceIsAtomicFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveBootloaderInterfaceMethod (t :: Symbol) (o :: *) :: * where + ResolveBootloaderInterfaceMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootloaderInterfaceMethod t BootloaderInterface, O.MethodInfo info BootloaderInterface p) => OL.IsLabel t (BootloaderInterface -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/BootloaderInterface.hs-boot b/GI/OSTree/Structs/BootloaderInterface.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderInterface.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.BootloaderInterface 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype BootloaderInterface = BootloaderInterface (ManagedPtr BootloaderInterface) +instance WrappedPtr BootloaderInterface where diff --git a/GI/OSTree/Structs/BootloaderSyslinux.hs b/GI/OSTree/Structs/BootloaderSyslinux.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderSyslinux.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.BootloaderSyslinux + ( + +-- * Exported types + BootloaderSyslinux(..) , + noBootloaderSyslinux , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype BootloaderSyslinux = BootloaderSyslinux (ManagedPtr BootloaderSyslinux) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr BootloaderSyslinux where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `BootloaderSyslinux`. +noBootloaderSyslinux :: Maybe BootloaderSyslinux +noBootloaderSyslinux = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BootloaderSyslinux +type instance O.AttributeList BootloaderSyslinux = BootloaderSyslinuxAttributeList +type BootloaderSyslinuxAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveBootloaderSyslinuxMethod (t :: Symbol) (o :: *) :: * where + ResolveBootloaderSyslinuxMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootloaderSyslinuxMethod t BootloaderSyslinux, O.MethodInfo info BootloaderSyslinux p) => OL.IsLabel t (BootloaderSyslinux -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/BootloaderSyslinux.hs-boot b/GI/OSTree/Structs/BootloaderSyslinux.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderSyslinux.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.BootloaderSyslinux 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype BootloaderSyslinux = BootloaderSyslinux (ManagedPtr BootloaderSyslinux) +instance WrappedPtr BootloaderSyslinux where diff --git a/GI/OSTree/Structs/BootloaderUboot.hs b/GI/OSTree/Structs/BootloaderUboot.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderUboot.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.BootloaderUboot + ( + +-- * Exported types + BootloaderUboot(..) , + noBootloaderUboot , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype BootloaderUboot = BootloaderUboot (ManagedPtr BootloaderUboot) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr BootloaderUboot where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `BootloaderUboot`. +noBootloaderUboot :: Maybe BootloaderUboot +noBootloaderUboot = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BootloaderUboot +type instance O.AttributeList BootloaderUboot = BootloaderUbootAttributeList +type BootloaderUbootAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveBootloaderUbootMethod (t :: Symbol) (o :: *) :: * where + ResolveBootloaderUbootMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBootloaderUbootMethod t BootloaderUboot, O.MethodInfo info BootloaderUboot p) => OL.IsLabel t (BootloaderUboot -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/BootloaderUboot.hs-boot b/GI/OSTree/Structs/BootloaderUboot.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/BootloaderUboot.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.BootloaderUboot 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype BootloaderUboot = BootloaderUboot (ManagedPtr BootloaderUboot) +instance WrappedPtr BootloaderUboot where diff --git a/GI/OSTree/Structs/CmdPrivateVTable.hs b/GI/OSTree/Structs/CmdPrivateVTable.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/CmdPrivateVTable.hs @@ -0,0 +1,589 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.CmdPrivateVTable + ( + +-- * Exported types + CmdPrivateVTable(..) , + newZeroCmdPrivateVTable , + noCmdPrivateVTable , + + + -- * Properties +-- ** ostreeFinalizeStaged #attr:ostreeFinalizeStaged# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeFinalizeStaged, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeFinalizeStaged , +#endif + getCmdPrivateVTableOstreeFinalizeStaged , + setCmdPrivateVTableOstreeFinalizeStaged , + + +-- ** ostreeGenerateGrub2Config #attr:ostreeGenerateGrub2Config# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeGenerateGrub2Config, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeGenerateGrub2Config, +#endif + getCmdPrivateVTableOstreeGenerateGrub2Config, + setCmdPrivateVTableOstreeGenerateGrub2Config, + + +-- ** ostreeRepoVerifyBindings #attr:ostreeRepoVerifyBindings# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeRepoVerifyBindings, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeRepoVerifyBindings, +#endif + getCmdPrivateVTableOstreeRepoVerifyBindings, + setCmdPrivateVTableOstreeRepoVerifyBindings, + + +-- ** ostreeStaticDeltaDelete #attr:ostreeStaticDeltaDelete# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeStaticDeltaDelete, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeStaticDeltaDelete, +#endif + getCmdPrivateVTableOstreeStaticDeltaDelete, + setCmdPrivateVTableOstreeStaticDeltaDelete, + + +-- ** ostreeStaticDeltaDump #attr:ostreeStaticDeltaDump# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeStaticDeltaDump, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeStaticDeltaDump , +#endif + getCmdPrivateVTableOstreeStaticDeltaDump, + setCmdPrivateVTableOstreeStaticDeltaDump, + + +-- ** ostreeStaticDeltaQueryExists #attr:ostreeStaticDeltaQueryExists# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeStaticDeltaQueryExists, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeStaticDeltaQueryExists, +#endif + getCmdPrivateVTableOstreeStaticDeltaQueryExists, + setCmdPrivateVTableOstreeStaticDeltaQueryExists, + + +-- ** ostreeSystemGenerator #attr:ostreeSystemGenerator# +{- | /No description available in the introspection data./ +-} + clearCmdPrivateVTableOstreeSystemGenerator, +#if ENABLE_OVERLOADING + cmdPrivateVTable_ostreeSystemGenerator , +#endif + getCmdPrivateVTableOstreeSystemGenerator, + setCmdPrivateVTableOstreeSystemGenerator, + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.OSTree.Callbacks as OSTree.Callbacks + +-- | Memory-managed wrapper type. +newtype CmdPrivateVTable = CmdPrivateVTable (ManagedPtr CmdPrivateVTable) +instance WrappedPtr CmdPrivateVTable where + wrappedPtrCalloc = callocBytes 56 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr CmdPrivateVTable) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `CmdPrivateVTable` struct initialized to zero. +newZeroCmdPrivateVTable :: MonadIO m => m CmdPrivateVTable +newZeroCmdPrivateVTable = liftIO $ wrappedPtrCalloc >>= wrapPtr CmdPrivateVTable + +instance tag ~ 'AttrSet => Constructible CmdPrivateVTable tag where + new _ attrs = do + o <- newZeroCmdPrivateVTable + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `CmdPrivateVTable`. +noCmdPrivateVTable :: Maybe CmdPrivateVTable +noCmdPrivateVTable = Nothing + +{- | +Get the value of the “@ostree_system_generator@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeSystemGenerator +@ +-} +getCmdPrivateVTableOstreeSystemGenerator :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeSystemGeneratorFieldCallback) +getCmdPrivateVTableOstreeSystemGenerator s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_system_generator@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeSystemGenerator 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeSystemGenerator :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback -> m () +setCmdPrivateVTableOstreeSystemGenerator s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback) + +{- | +Set the value of the “@ostree_system_generator@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeSystemGenerator +@ +-} +clearCmdPrivateVTableOstreeSystemGenerator :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeSystemGenerator s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeSystemGeneratorFieldInfo +instance AttrInfo CmdPrivateVTableOstreeSystemGeneratorFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeSystemGeneratorFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeSystemGeneratorFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeSystemGeneratorFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeSystemGeneratorFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeSystemGeneratorFieldCallback + type AttrLabel CmdPrivateVTableOstreeSystemGeneratorFieldInfo = "ostree_system_generator" + type AttrOrigin CmdPrivateVTableOstreeSystemGeneratorFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeSystemGenerator + attrSet _ = setCmdPrivateVTableOstreeSystemGenerator + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeSystemGenerator + +cmdPrivateVTable_ostreeSystemGenerator :: AttrLabelProxy "ostreeSystemGenerator" +cmdPrivateVTable_ostreeSystemGenerator = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_generate_grub2_config@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeGenerateGrub2Config +@ +-} +getCmdPrivateVTableOstreeGenerateGrub2Config :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) +getCmdPrivateVTableOstreeGenerateGrub2Config s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_generate_grub2_config@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeGenerateGrub2Config 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeGenerateGrub2Config :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback -> m () +setCmdPrivateVTableOstreeGenerateGrub2Config s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) + +{- | +Set the value of the “@ostree_generate_grub2_config@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeGenerateGrub2Config +@ +-} +clearCmdPrivateVTableOstreeGenerateGrub2Config :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeGenerateGrub2Config s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo +instance AttrInfo CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback + type AttrLabel CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = "ostree_generate_grub2_config" + type AttrOrigin CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeGenerateGrub2Config + attrSet _ = setCmdPrivateVTableOstreeGenerateGrub2Config + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeGenerateGrub2Config + +cmdPrivateVTable_ostreeGenerateGrub2Config :: AttrLabelProxy "ostreeGenerateGrub2Config" +cmdPrivateVTable_ostreeGenerateGrub2Config = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_static_delta_dump@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeStaticDeltaDump +@ +-} +getCmdPrivateVTableOstreeStaticDeltaDump :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) +getCmdPrivateVTableOstreeStaticDeltaDump s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_static_delta_dump@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeStaticDeltaDump 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeStaticDeltaDump :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback -> m () +setCmdPrivateVTableOstreeStaticDeltaDump s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) + +{- | +Set the value of the “@ostree_static_delta_dump@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeStaticDeltaDump +@ +-} +clearCmdPrivateVTableOstreeStaticDeltaDump :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeStaticDeltaDump s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo +instance AttrInfo CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback + type AttrLabel CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = "ostree_static_delta_dump" + type AttrOrigin CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeStaticDeltaDump + attrSet _ = setCmdPrivateVTableOstreeStaticDeltaDump + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeStaticDeltaDump + +cmdPrivateVTable_ostreeStaticDeltaDump :: AttrLabelProxy "ostreeStaticDeltaDump" +cmdPrivateVTable_ostreeStaticDeltaDump = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_static_delta_query_exists@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeStaticDeltaQueryExists +@ +-} +getCmdPrivateVTableOstreeStaticDeltaQueryExists :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) +getCmdPrivateVTableOstreeStaticDeltaQueryExists s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_static_delta_query_exists@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeStaticDeltaQueryExists 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeStaticDeltaQueryExists :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback -> m () +setCmdPrivateVTableOstreeStaticDeltaQueryExists s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) + +{- | +Set the value of the “@ostree_static_delta_query_exists@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeStaticDeltaQueryExists +@ +-} +clearCmdPrivateVTableOstreeStaticDeltaQueryExists :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeStaticDeltaQueryExists s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo +instance AttrInfo CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback + type AttrLabel CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = "ostree_static_delta_query_exists" + type AttrOrigin CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeStaticDeltaQueryExists + attrSet _ = setCmdPrivateVTableOstreeStaticDeltaQueryExists + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeStaticDeltaQueryExists + +cmdPrivateVTable_ostreeStaticDeltaQueryExists :: AttrLabelProxy "ostreeStaticDeltaQueryExists" +cmdPrivateVTable_ostreeStaticDeltaQueryExists = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_static_delta_delete@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeStaticDeltaDelete +@ +-} +getCmdPrivateVTableOstreeStaticDeltaDelete :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) +getCmdPrivateVTableOstreeStaticDeltaDelete s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_static_delta_delete@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeStaticDeltaDelete 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeStaticDeltaDelete :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback -> m () +setCmdPrivateVTableOstreeStaticDeltaDelete s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) + +{- | +Set the value of the “@ostree_static_delta_delete@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeStaticDeltaDelete +@ +-} +clearCmdPrivateVTableOstreeStaticDeltaDelete :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeStaticDeltaDelete s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo +instance AttrInfo CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback + type AttrLabel CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = "ostree_static_delta_delete" + type AttrOrigin CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeStaticDeltaDelete + attrSet _ = setCmdPrivateVTableOstreeStaticDeltaDelete + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeStaticDeltaDelete + +cmdPrivateVTable_ostreeStaticDeltaDelete :: AttrLabelProxy "ostreeStaticDeltaDelete" +cmdPrivateVTable_ostreeStaticDeltaDelete = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_repo_verify_bindings@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeRepoVerifyBindings +@ +-} +getCmdPrivateVTableOstreeRepoVerifyBindings :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) +getCmdPrivateVTableOstreeRepoVerifyBindings s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_repo_verify_bindings@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeRepoVerifyBindings 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeRepoVerifyBindings :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback -> m () +setCmdPrivateVTableOstreeRepoVerifyBindings s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) + +{- | +Set the value of the “@ostree_repo_verify_bindings@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeRepoVerifyBindings +@ +-} +clearCmdPrivateVTableOstreeRepoVerifyBindings :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeRepoVerifyBindings s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo +instance AttrInfo CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback + type AttrLabel CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = "ostree_repo_verify_bindings" + type AttrOrigin CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeRepoVerifyBindings + attrSet _ = setCmdPrivateVTableOstreeRepoVerifyBindings + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeRepoVerifyBindings + +cmdPrivateVTable_ostreeRepoVerifyBindings :: AttrLabelProxy "ostreeRepoVerifyBindings" +cmdPrivateVTable_ostreeRepoVerifyBindings = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ostree_finalize_staged@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cmdPrivateVTable #ostreeFinalizeStaged +@ +-} +getCmdPrivateVTableOstreeFinalizeStaged :: MonadIO m => CmdPrivateVTable -> m (Maybe OSTree.Callbacks.CmdPrivateVTableOstreeFinalizeStagedFieldCallback) +getCmdPrivateVTableOstreeFinalizeStaged s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@ostree_finalize_staged@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cmdPrivateVTable [ #ostreeFinalizeStaged 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCmdPrivateVTableOstreeFinalizeStaged :: MonadIO m => CmdPrivateVTable -> FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback -> m () +setCmdPrivateVTableOstreeFinalizeStaged s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback) + +{- | +Set the value of the “@ostree_finalize_staged@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ostreeFinalizeStaged +@ +-} +clearCmdPrivateVTableOstreeFinalizeStaged :: MonadIO m => CmdPrivateVTable -> m () +clearCmdPrivateVTableOstreeFinalizeStaged s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback) + +#if ENABLE_OVERLOADING +data CmdPrivateVTableOstreeFinalizeStagedFieldInfo +instance AttrInfo CmdPrivateVTableOstreeFinalizeStagedFieldInfo where + type AttrAllowedOps CmdPrivateVTableOstreeFinalizeStagedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CmdPrivateVTableOstreeFinalizeStagedFieldInfo = (~) (FunPtr OSTree.Callbacks.C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback) + type AttrBaseTypeConstraint CmdPrivateVTableOstreeFinalizeStagedFieldInfo = (~) CmdPrivateVTable + type AttrGetType CmdPrivateVTableOstreeFinalizeStagedFieldInfo = Maybe OSTree.Callbacks.CmdPrivateVTableOstreeFinalizeStagedFieldCallback + type AttrLabel CmdPrivateVTableOstreeFinalizeStagedFieldInfo = "ostree_finalize_staged" + type AttrOrigin CmdPrivateVTableOstreeFinalizeStagedFieldInfo = CmdPrivateVTable + attrGet _ = getCmdPrivateVTableOstreeFinalizeStaged + attrSet _ = setCmdPrivateVTableOstreeFinalizeStaged + attrConstruct = undefined + attrClear _ = clearCmdPrivateVTableOstreeFinalizeStaged + +cmdPrivateVTable_ostreeFinalizeStaged :: AttrLabelProxy "ostreeFinalizeStaged" +cmdPrivateVTable_ostreeFinalizeStaged = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CmdPrivateVTable +type instance O.AttributeList CmdPrivateVTable = CmdPrivateVTableAttributeList +type CmdPrivateVTableAttributeList = ('[ '("ostreeSystemGenerator", CmdPrivateVTableOstreeSystemGeneratorFieldInfo), '("ostreeGenerateGrub2Config", CmdPrivateVTableOstreeGenerateGrub2ConfigFieldInfo), '("ostreeStaticDeltaDump", CmdPrivateVTableOstreeStaticDeltaDumpFieldInfo), '("ostreeStaticDeltaQueryExists", CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldInfo), '("ostreeStaticDeltaDelete", CmdPrivateVTableOstreeStaticDeltaDeleteFieldInfo), '("ostreeRepoVerifyBindings", CmdPrivateVTableOstreeRepoVerifyBindingsFieldInfo), '("ostreeFinalizeStaged", CmdPrivateVTableOstreeFinalizeStagedFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveCmdPrivateVTableMethod (t :: Symbol) (o :: *) :: * where + ResolveCmdPrivateVTableMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCmdPrivateVTableMethod t CmdPrivateVTable, O.MethodInfo info CmdPrivateVTable p) => OL.IsLabel t (CmdPrivateVTable -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/CmdPrivateVTable.hs-boot b/GI/OSTree/Structs/CmdPrivateVTable.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/CmdPrivateVTable.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.CmdPrivateVTable 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype CmdPrivateVTable = CmdPrivateVTable (ManagedPtr CmdPrivateVTable) +instance WrappedPtr CmdPrivateVTable where diff --git a/GI/OSTree/Structs/CollectionRef.hs b/GI/OSTree/Structs/CollectionRef.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/CollectionRef.hs @@ -0,0 +1,543 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A structure which globally uniquely identifies a ref as the tuple +(/@collectionId@/, /@refName@/). For backwards compatibility, /@collectionId@/ may be 'Nothing', +indicating a ref name which is not globally unique. + +/Since: 2018.6/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.CollectionRef + ( + +-- * Exported types + CollectionRef(..) , + newZeroCollectionRef , + noCollectionRef , + + + -- * Methods +-- ** dup #method:dup# + +#if ENABLE_OVERLOADING + CollectionRefDupMethodInfo , +#endif + collectionRefDup , + + +-- ** dupv #method:dupv# + + collectionRefDupv , + + +-- ** equal #method:equal# + + collectionRefEqual , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + CollectionRefFreeMethodInfo , +#endif + collectionRefFree , + + +-- ** freev #method:freev# + + collectionRefFreev , + + +-- ** hash #method:hash# + + collectionRefHash , + + +-- ** new #method:new# + + collectionRefNew , + + + + + -- * Properties +-- ** collectionId #attr:collectionId# +{- | collection ID which provided the ref, or 'Nothing' if there + is no associated collection +-} + clearCollectionRefCollectionId , +#if ENABLE_OVERLOADING + collectionRef_collectionId , +#endif + getCollectionRefCollectionId , + setCollectionRefCollectionId , + + +-- ** refName #attr:refName# +{- | ref name +-} + clearCollectionRefRefName , +#if ENABLE_OVERLOADING + collectionRef_refName , +#endif + getCollectionRefRefName , + setCollectionRefRefName , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype CollectionRef = CollectionRef (ManagedPtr CollectionRef) +foreign import ccall "ostree_collection_ref_get_type" c_ostree_collection_ref_get_type :: + IO GType + +instance BoxedObject CollectionRef where + boxedType _ = c_ostree_collection_ref_get_type + +-- | Construct a `CollectionRef` struct initialized to zero. +newZeroCollectionRef :: MonadIO m => m CollectionRef +newZeroCollectionRef = liftIO $ callocBoxedBytes 16 >>= wrapBoxed CollectionRef + +instance tag ~ 'AttrSet => Constructible CollectionRef tag where + new _ attrs = do + o <- newZeroCollectionRef + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `CollectionRef`. +noCollectionRef :: Maybe CollectionRef +noCollectionRef = Nothing + +{- | +Get the value of the “@collection_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' collectionRef #collectionId +@ +-} +getCollectionRefCollectionId :: MonadIO m => CollectionRef -> m (Maybe T.Text) +getCollectionRefCollectionId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@collection_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' collectionRef [ #collectionId 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCollectionRefCollectionId :: MonadIO m => CollectionRef -> CString -> m () +setCollectionRefCollectionId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CString) + +{- | +Set the value of the “@collection_id@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #collectionId +@ +-} +clearCollectionRefCollectionId :: MonadIO m => CollectionRef -> m () +clearCollectionRefCollectionId s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data CollectionRefCollectionIdFieldInfo +instance AttrInfo CollectionRefCollectionIdFieldInfo where + type AttrAllowedOps CollectionRefCollectionIdFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CollectionRefCollectionIdFieldInfo = (~) CString + type AttrBaseTypeConstraint CollectionRefCollectionIdFieldInfo = (~) CollectionRef + type AttrGetType CollectionRefCollectionIdFieldInfo = Maybe T.Text + type AttrLabel CollectionRefCollectionIdFieldInfo = "collection_id" + type AttrOrigin CollectionRefCollectionIdFieldInfo = CollectionRef + attrGet _ = getCollectionRefCollectionId + attrSet _ = setCollectionRefCollectionId + attrConstruct = undefined + attrClear _ = clearCollectionRefCollectionId + +collectionRef_collectionId :: AttrLabelProxy "collectionId" +collectionRef_collectionId = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ref_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' collectionRef #refName +@ +-} +getCollectionRefRefName :: MonadIO m => CollectionRef -> m (Maybe T.Text) +getCollectionRefRefName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@ref_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' collectionRef [ #refName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCollectionRefRefName :: MonadIO m => CollectionRef -> CString -> m () +setCollectionRefRefName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@ref_name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #refName +@ +-} +clearCollectionRefRefName :: MonadIO m => CollectionRef -> m () +clearCollectionRefRefName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data CollectionRefRefNameFieldInfo +instance AttrInfo CollectionRefRefNameFieldInfo where + type AttrAllowedOps CollectionRefRefNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CollectionRefRefNameFieldInfo = (~) CString + type AttrBaseTypeConstraint CollectionRefRefNameFieldInfo = (~) CollectionRef + type AttrGetType CollectionRefRefNameFieldInfo = Maybe T.Text + type AttrLabel CollectionRefRefNameFieldInfo = "ref_name" + type AttrOrigin CollectionRefRefNameFieldInfo = CollectionRef + attrGet _ = getCollectionRefRefName + attrSet _ = setCollectionRefRefName + attrConstruct = undefined + attrClear _ = clearCollectionRefRefName + +collectionRef_refName :: AttrLabelProxy "refName" +collectionRef_refName = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CollectionRef +type instance O.AttributeList CollectionRef = CollectionRefAttributeList +type CollectionRefAttributeList = ('[ '("collectionId", CollectionRefCollectionIdFieldInfo), '("refName", CollectionRefRefNameFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method CollectionRef::new +-- method type : Constructor +-- Args : [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a collection ID, or %NULL for a plain ref", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a ref name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_new" ostree_collection_ref_new :: + CString -> -- collection_id : TBasicType TUTF8 + CString -> -- ref_name : TBasicType TUTF8 + IO (Ptr CollectionRef) + +{- | +Create a new 'GI.OSTree.Structs.CollectionRef.CollectionRef' containing (/@collectionId@/, /@refName@/). If +/@collectionId@/ is 'Nothing', this is equivalent to a plain ref name string (not a +refspec; no remote name is included), which can be used for non-P2P +operations. + +/Since: 2018.6/ +-} +collectionRefNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@collectionId@/: a collection ID, or 'Nothing' for a plain ref -} + -> T.Text + {- ^ /@refName@/: a ref name -} + -> m CollectionRef + {- ^ __Returns:__ a new 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} +collectionRefNew collectionId refName = liftIO $ do + maybeCollectionId <- case collectionId of + Nothing -> return nullPtr + Just jCollectionId -> do + jCollectionId' <- textToCString jCollectionId + return jCollectionId' + refName' <- textToCString refName + result <- ostree_collection_ref_new maybeCollectionId refName' + checkUnexpectedReturnNULL "collectionRefNew" result + result' <- (wrapBoxed CollectionRef) result + freeMem maybeCollectionId + freeMem refName' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CollectionRef::dup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "OSTree", name = "CollectionRef"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeCollectionRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_dup" ostree_collection_ref_dup :: + Ptr CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) + IO (Ptr CollectionRef) + +{- | +Create a copy of the given /@ref@/. + +/Since: 2018.6/ +-} +collectionRefDup :: + (B.CallStack.HasCallStack, MonadIO m) => + CollectionRef + {- ^ /@ref@/: an 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} + -> m CollectionRef + {- ^ __Returns:__ a newly allocated copy of /@ref@/ -} +collectionRefDup ref = liftIO $ do + ref' <- unsafeManagedPtrGetPtr ref + result <- ostree_collection_ref_dup ref' + checkUnexpectedReturnNULL "collectionRefDup" result + result' <- (wrapBoxed CollectionRef) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data CollectionRefDupMethodInfo +instance (signature ~ (m CollectionRef), MonadIO m) => O.MethodInfo CollectionRefDupMethodInfo CollectionRef signature where + overloadedMethod _ = collectionRefDup + +#endif + +-- method CollectionRef::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "OSTree", name = "CollectionRef"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeCollectionRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_free" ostree_collection_ref_free :: + Ptr CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) + IO () + +{- | +Free the given /@ref@/. + +/Since: 2018.6/ +-} +collectionRefFree :: + (B.CallStack.HasCallStack, MonadIO m) => + CollectionRef + {- ^ /@ref@/: an 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} + -> m () +collectionRefFree ref = liftIO $ do + ref' <- B.ManagedPtr.disownBoxed ref + ostree_collection_ref_free ref' + touchManagedPtr ref + return () + +#if ENABLE_OVERLOADING +data CollectionRefFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo CollectionRefFreeMethodInfo CollectionRef signature where + overloadedMethod _ = collectionRefFree + +#endif + +-- method CollectionRef::dupv +-- method type : MemberFunction +-- Args : [Arg {argCName = "refs", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%NULL-terminated array of #OstreeCollectionRefs", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_dupv" ostree_collection_ref_dupv :: + Ptr (Ptr CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) + IO (Ptr (Ptr CollectionRef)) + +{- | +Copy an array of @/OstreeCollectionRefs/@, including deep copies of all its +elements. /@refs@/ must be 'Nothing'-terminated; it may be empty, but must not be +'Nothing'. + +/Since: 2018.6/ +-} +collectionRefDupv :: + (B.CallStack.HasCallStack, MonadIO m) => + [CollectionRef] + {- ^ /@refs@/: 'Nothing'-terminated array of @/OstreeCollectionRefs/@ -} + -> m [CollectionRef] + {- ^ __Returns:__ a newly allocated copy of /@refs@/ -} +collectionRefDupv refs = liftIO $ do + refs' <- mapM unsafeManagedPtrGetPtr refs + refs'' <- packZeroTerminatedPtrArray refs' + result <- ostree_collection_ref_dupv refs'' + checkUnexpectedReturnNULL "collectionRefDupv" result + result' <- unpackZeroTerminatedPtrArray result + result'' <- mapM (wrapBoxed CollectionRef) result' + freeMem result + mapM_ touchManagedPtr refs + freeMem refs'' + return result'' + +#if ENABLE_OVERLOADING +#endif + +-- method CollectionRef::equal +-- method type : MemberFunction +-- Args : [Arg {argCName = "ref1", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an #OstreeCollectionRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref2", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "another #OstreeCollectionRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_equal" ostree_collection_ref_equal :: + Ptr () -> -- ref1 : TBasicType TPtr + Ptr () -> -- ref2 : TBasicType TPtr + IO CInt + +{- | +Compare /@ref1@/ and /@ref2@/ and return 'True' if they have the same collection ID and +ref name, and 'False' otherwise. Both /@ref1@/ and /@ref2@/ must be non-'Nothing'. + +/Since: 2018.6/ +-} +collectionRefEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + {- ^ /@ref1@/: an 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} + -> Ptr () + {- ^ /@ref2@/: another 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@ref1@/ and /@ref2@/ are equal, 'False' otherwise -} +collectionRefEqual ref1 ref2 = liftIO $ do + result <- ostree_collection_ref_equal ref1 ref2 + let result' = (/= 0) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CollectionRef::freev +-- method type : MemberFunction +-- Args : [Arg {argCName = "refs", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an array of #OstreeCollectionRefs", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_freev" ostree_collection_ref_freev :: + Ptr (Ptr CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"})) + IO () + +{- | +Free the given array of /@refs@/, including freeing all its elements. /@refs@/ +must be 'Nothing'-terminated; it may be empty, but must not be 'Nothing'. + +/Since: 2018.6/ +-} +collectionRefFreev :: + (B.CallStack.HasCallStack, MonadIO m) => + [CollectionRef] + {- ^ /@refs@/: an array of @/OstreeCollectionRefs/@ -} + -> m () +collectionRefFreev refs = liftIO $ do + refs' <- mapM B.ManagedPtr.disownBoxed refs + refs'' <- packZeroTerminatedPtrArray refs' + ostree_collection_ref_freev refs'' + mapM_ touchManagedPtr refs + return () + +#if ENABLE_OVERLOADING +#endif + +-- method CollectionRef::hash +-- method type : MemberFunction +-- Args : [Arg {argCName = "ref", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an #OstreeCollectionRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_collection_ref_hash" ostree_collection_ref_hash :: + Ptr () -> -- ref : TBasicType TPtr + IO Word32 + +{- | +Hash the given /@ref@/. This function is suitable for use with 'GI.GLib.Structs.HashTable.HashTable'. +/@ref@/ must be non-'Nothing'. + +/Since: 2018.6/ +-} +collectionRefHash :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + {- ^ /@ref@/: an 'GI.OSTree.Structs.CollectionRef.CollectionRef' -} + -> m Word32 + {- ^ __Returns:__ hash value for /@ref@/ -} +collectionRefHash ref = liftIO $ do + result <- ostree_collection_ref_hash ref + return result + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveCollectionRefMethod (t :: Symbol) (o :: *) :: * where + ResolveCollectionRefMethod "dup" o = CollectionRefDupMethodInfo + ResolveCollectionRefMethod "free" o = CollectionRefFreeMethodInfo + ResolveCollectionRefMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCollectionRefMethod t CollectionRef, O.MethodInfo info CollectionRef p) => OL.IsLabel t (CollectionRef -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/CollectionRef.hs-boot b/GI/OSTree/Structs/CollectionRef.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/CollectionRef.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.CollectionRef 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype CollectionRef = CollectionRef (ManagedPtr CollectionRef) +instance BoxedObject CollectionRef where +#if ENABLE_OVERLOADING +data CollectionRefDupMethodInfo +#endif +#if ENABLE_OVERLOADING +data CollectionRefFreeMethodInfo +#endif diff --git a/GI/OSTree/Structs/DiffDirsOptions.hs b/GI/OSTree/Structs/DiffDirsOptions.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/DiffDirsOptions.hs @@ -0,0 +1,278 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An extensible options structure controlling diff dirs. Make sure +that owner_uid\/gid is set to -1 when not used. This is used by +'GI.OSTree.Functions.diffDirsWithOptions'. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.DiffDirsOptions + ( + +-- * Exported types + DiffDirsOptions(..) , + newZeroDiffDirsOptions , + noDiffDirsOptions , + + + -- * Properties +-- ** devinoToCsumCache #attr:devinoToCsumCache# +{- | /No description available in the introspection data./ +-} + clearDiffDirsOptionsDevinoToCsumCache , +#if ENABLE_OVERLOADING + diffDirsOptions_devinoToCsumCache , +#endif + getDiffDirsOptionsDevinoToCsumCache , + setDiffDirsOptionsDevinoToCsumCache , + + +-- ** ownerGid #attr:ownerGid# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + diffDirsOptions_ownerGid , +#endif + getDiffDirsOptionsOwnerGid , + setDiffDirsOptionsOwnerGid , + + +-- ** ownerUid #attr:ownerUid# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + diffDirsOptions_ownerUid , +#endif + getDiffDirsOptionsOwnerUid , + setDiffDirsOptionsOwnerUid , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache + +-- | Memory-managed wrapper type. +newtype DiffDirsOptions = DiffDirsOptions (ManagedPtr DiffDirsOptions) +instance WrappedPtr DiffDirsOptions where + wrappedPtrCalloc = callocBytes 128 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 128 >=> wrapPtr DiffDirsOptions) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `DiffDirsOptions` struct initialized to zero. +newZeroDiffDirsOptions :: MonadIO m => m DiffDirsOptions +newZeroDiffDirsOptions = liftIO $ wrappedPtrCalloc >>= wrapPtr DiffDirsOptions + +instance tag ~ 'AttrSet => Constructible DiffDirsOptions tag where + new _ attrs = do + o <- newZeroDiffDirsOptions + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffDirsOptions`. +noDiffDirsOptions :: Maybe DiffDirsOptions +noDiffDirsOptions = Nothing + +{- | +Get the value of the “@owner_uid@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffDirsOptions #ownerUid +@ +-} +getDiffDirsOptionsOwnerUid :: MonadIO m => DiffDirsOptions -> m Int32 +getDiffDirsOptionsOwnerUid s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@owner_uid@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffDirsOptions [ #ownerUid 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffDirsOptionsOwnerUid :: MonadIO m => DiffDirsOptions -> Int32 -> m () +setDiffDirsOptionsOwnerUid s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data DiffDirsOptionsOwnerUidFieldInfo +instance AttrInfo DiffDirsOptionsOwnerUidFieldInfo where + type AttrAllowedOps DiffDirsOptionsOwnerUidFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DiffDirsOptionsOwnerUidFieldInfo = (~) Int32 + type AttrBaseTypeConstraint DiffDirsOptionsOwnerUidFieldInfo = (~) DiffDirsOptions + type AttrGetType DiffDirsOptionsOwnerUidFieldInfo = Int32 + type AttrLabel DiffDirsOptionsOwnerUidFieldInfo = "owner_uid" + type AttrOrigin DiffDirsOptionsOwnerUidFieldInfo = DiffDirsOptions + attrGet _ = getDiffDirsOptionsOwnerUid + attrSet _ = setDiffDirsOptionsOwnerUid + attrConstruct = undefined + attrClear _ = undefined + +diffDirsOptions_ownerUid :: AttrLabelProxy "ownerUid" +diffDirsOptions_ownerUid = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@owner_gid@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffDirsOptions #ownerGid +@ +-} +getDiffDirsOptionsOwnerGid :: MonadIO m => DiffDirsOptions -> m Int32 +getDiffDirsOptionsOwnerGid s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Int32 + return val + +{- | +Set the value of the “@owner_gid@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffDirsOptions [ #ownerGid 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffDirsOptionsOwnerGid :: MonadIO m => DiffDirsOptions -> Int32 -> m () +setDiffDirsOptionsOwnerGid s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Int32) + +#if ENABLE_OVERLOADING +data DiffDirsOptionsOwnerGidFieldInfo +instance AttrInfo DiffDirsOptionsOwnerGidFieldInfo where + type AttrAllowedOps DiffDirsOptionsOwnerGidFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DiffDirsOptionsOwnerGidFieldInfo = (~) Int32 + type AttrBaseTypeConstraint DiffDirsOptionsOwnerGidFieldInfo = (~) DiffDirsOptions + type AttrGetType DiffDirsOptionsOwnerGidFieldInfo = Int32 + type AttrLabel DiffDirsOptionsOwnerGidFieldInfo = "owner_gid" + type AttrOrigin DiffDirsOptionsOwnerGidFieldInfo = DiffDirsOptions + attrGet _ = getDiffDirsOptionsOwnerGid + attrSet _ = setDiffDirsOptionsOwnerGid + attrConstruct = undefined + attrClear _ = undefined + +diffDirsOptions_ownerGid :: AttrLabelProxy "ownerGid" +diffDirsOptions_ownerGid = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@devino_to_csum_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffDirsOptions #devinoToCsumCache +@ +-} +getDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> m (Maybe OSTree.RepoDevInoCache.RepoDevInoCache) +getDiffDirsOptionsDevinoToCsumCache s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed OSTree.RepoDevInoCache.RepoDevInoCache) val' + return val'' + return result + +{- | +Set the value of the “@devino_to_csum_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffDirsOptions [ #devinoToCsumCache 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> Ptr OSTree.RepoDevInoCache.RepoDevInoCache -> m () +setDiffDirsOptionsDevinoToCsumCache s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + +{- | +Set the value of the “@devino_to_csum_cache@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #devinoToCsumCache +@ +-} +clearDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> m () +clearDiffDirsOptionsDevinoToCsumCache s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + +#if ENABLE_OVERLOADING +data DiffDirsOptionsDevinoToCsumCacheFieldInfo +instance AttrInfo DiffDirsOptionsDevinoToCsumCacheFieldInfo where + type AttrAllowedOps DiffDirsOptionsDevinoToCsumCacheFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffDirsOptionsDevinoToCsumCacheFieldInfo = (~) (Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + type AttrBaseTypeConstraint DiffDirsOptionsDevinoToCsumCacheFieldInfo = (~) DiffDirsOptions + type AttrGetType DiffDirsOptionsDevinoToCsumCacheFieldInfo = Maybe OSTree.RepoDevInoCache.RepoDevInoCache + type AttrLabel DiffDirsOptionsDevinoToCsumCacheFieldInfo = "devino_to_csum_cache" + type AttrOrigin DiffDirsOptionsDevinoToCsumCacheFieldInfo = DiffDirsOptions + attrGet _ = getDiffDirsOptionsDevinoToCsumCache + attrSet _ = setDiffDirsOptionsDevinoToCsumCache + attrConstruct = undefined + attrClear _ = clearDiffDirsOptionsDevinoToCsumCache + +diffDirsOptions_devinoToCsumCache :: AttrLabelProxy "devinoToCsumCache" +diffDirsOptions_devinoToCsumCache = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "DiffDirsOptions:unused_bools" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TBoolean)" +-- XXX Skipped attribute for "DiffDirsOptions:unused_ints" :: Not implemented: "Don't know how to unpack C array of type TCArray False 6 (-1) (TBasicType TInt)" +-- XXX Skipped attribute for "DiffDirsOptions:unused_ptrs" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TPtr)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffDirsOptions +type instance O.AttributeList DiffDirsOptions = DiffDirsOptionsAttributeList +type DiffDirsOptionsAttributeList = ('[ '("ownerUid", DiffDirsOptionsOwnerUidFieldInfo), '("ownerGid", DiffDirsOptionsOwnerGidFieldInfo), '("devinoToCsumCache", DiffDirsOptionsDevinoToCsumCacheFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffDirsOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffDirsOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffDirsOptionsMethod t DiffDirsOptions, O.MethodInfo info DiffDirsOptions p) => OL.IsLabel t (DiffDirsOptions -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/DiffDirsOptions.hs-boot b/GI/OSTree/Structs/DiffDirsOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/DiffDirsOptions.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.DiffDirsOptions 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype DiffDirsOptions = DiffDirsOptions (ManagedPtr DiffDirsOptions) +instance WrappedPtr DiffDirsOptions where diff --git a/GI/OSTree/Structs/DiffItem.hs b/GI/OSTree/Structs/DiffItem.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/DiffItem.hs @@ -0,0 +1,662 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.DiffItem + ( + +-- * Exported types + DiffItem(..) , + newZeroDiffItem , + noDiffItem , + + + -- * Methods +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffItemRefMethodInfo , +#endif + diffItemRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffItemUnrefMethodInfo , +#endif + diffItemUnref , + + + + + -- * Properties +-- ** refcount #attr:refcount# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + diffItem_refcount , +#endif + getDiffItemRefcount , + setDiffItemRefcount , + + +-- ** src #attr:src# +{- | /No description available in the introspection data./ +-} + clearDiffItemSrc , +#if ENABLE_OVERLOADING + diffItem_src , +#endif + getDiffItemSrc , + setDiffItemSrc , + + +-- ** srcChecksum #attr:srcChecksum# +{- | /No description available in the introspection data./ +-} + clearDiffItemSrcChecksum , +#if ENABLE_OVERLOADING + diffItem_srcChecksum , +#endif + getDiffItemSrcChecksum , + setDiffItemSrcChecksum , + + +-- ** srcInfo #attr:srcInfo# +{- | /No description available in the introspection data./ +-} + clearDiffItemSrcInfo , +#if ENABLE_OVERLOADING + diffItem_srcInfo , +#endif + getDiffItemSrcInfo , + setDiffItemSrcInfo , + + +-- ** target #attr:target# +{- | /No description available in the introspection data./ +-} + clearDiffItemTarget , +#if ENABLE_OVERLOADING + diffItem_target , +#endif + getDiffItemTarget , + setDiffItemTarget , + + +-- ** targetChecksum #attr:targetChecksum# +{- | /No description available in the introspection data./ +-} + clearDiffItemTargetChecksum , +#if ENABLE_OVERLOADING + diffItem_targetChecksum , +#endif + getDiffItemTargetChecksum , + setDiffItemTargetChecksum , + + +-- ** targetInfo #attr:targetInfo# +{- | /No description available in the introspection data./ +-} + clearDiffItemTargetInfo , +#if ENABLE_OVERLOADING + diffItem_targetInfo , +#endif + getDiffItemTargetInfo , + setDiffItemTargetInfo , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo + +-- | Memory-managed wrapper type. +newtype DiffItem = DiffItem (ManagedPtr DiffItem) +foreign import ccall "ostree_diff_item_get_type" c_ostree_diff_item_get_type :: + IO GType + +instance BoxedObject DiffItem where + boxedType _ = c_ostree_diff_item_get_type + +-- | Construct a `DiffItem` struct initialized to zero. +newZeroDiffItem :: MonadIO m => m DiffItem +newZeroDiffItem = liftIO $ callocBoxedBytes 56 >>= wrapBoxed DiffItem + +instance tag ~ 'AttrSet => Constructible DiffItem tag where + new _ attrs = do + o <- newZeroDiffItem + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffItem`. +noDiffItem :: Maybe DiffItem +noDiffItem = Nothing + +{- | +Get the value of the “@refcount@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #refcount +@ +-} +getDiffItemRefcount :: MonadIO m => DiffItem -> m Int32 +getDiffItemRefcount s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@refcount@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #refcount 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemRefcount :: MonadIO m => DiffItem -> Int32 -> m () +setDiffItemRefcount s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data DiffItemRefcountFieldInfo +instance AttrInfo DiffItemRefcountFieldInfo where + type AttrAllowedOps DiffItemRefcountFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DiffItemRefcountFieldInfo = (~) Int32 + type AttrBaseTypeConstraint DiffItemRefcountFieldInfo = (~) DiffItem + type AttrGetType DiffItemRefcountFieldInfo = Int32 + type AttrLabel DiffItemRefcountFieldInfo = "refcount" + type AttrOrigin DiffItemRefcountFieldInfo = DiffItem + attrGet _ = getDiffItemRefcount + attrSet _ = setDiffItemRefcount + attrConstruct = undefined + attrClear _ = undefined + +diffItem_refcount :: AttrLabelProxy "refcount" +diffItem_refcount = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@src@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #src +@ +-} +getDiffItemSrc :: MonadIO m => DiffItem -> m (Maybe Gio.File.File) +getDiffItemSrc s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gio.File.File) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Gio.File.File) val' + return val'' + return result + +{- | +Set the value of the “@src@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #src 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemSrc :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m () +setDiffItemSrc s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr Gio.File.File) + +{- | +Set the value of the “@src@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #src +@ +-} +clearDiffItemSrc :: MonadIO m => DiffItem -> m () +clearDiffItemSrc s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gio.File.File) + +#if ENABLE_OVERLOADING +data DiffItemSrcFieldInfo +instance AttrInfo DiffItemSrcFieldInfo where + type AttrAllowedOps DiffItemSrcFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemSrcFieldInfo = (~) (Ptr Gio.File.File) + type AttrBaseTypeConstraint DiffItemSrcFieldInfo = (~) DiffItem + type AttrGetType DiffItemSrcFieldInfo = Maybe Gio.File.File + type AttrLabel DiffItemSrcFieldInfo = "src" + type AttrOrigin DiffItemSrcFieldInfo = DiffItem + attrGet _ = getDiffItemSrc + attrSet _ = setDiffItemSrc + attrConstruct = undefined + attrClear _ = clearDiffItemSrc + +diffItem_src :: AttrLabelProxy "src" +diffItem_src = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@target@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #target +@ +-} +getDiffItemTarget :: MonadIO m => DiffItem -> m (Maybe Gio.File.File) +getDiffItemTarget s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gio.File.File) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Gio.File.File) val' + return val'' + return result + +{- | +Set the value of the “@target@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #target 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemTarget :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m () +setDiffItemTarget s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr Gio.File.File) + +{- | +Set the value of the “@target@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #target +@ +-} +clearDiffItemTarget :: MonadIO m => DiffItem -> m () +clearDiffItemTarget s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gio.File.File) + +#if ENABLE_OVERLOADING +data DiffItemTargetFieldInfo +instance AttrInfo DiffItemTargetFieldInfo where + type AttrAllowedOps DiffItemTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemTargetFieldInfo = (~) (Ptr Gio.File.File) + type AttrBaseTypeConstraint DiffItemTargetFieldInfo = (~) DiffItem + type AttrGetType DiffItemTargetFieldInfo = Maybe Gio.File.File + type AttrLabel DiffItemTargetFieldInfo = "target" + type AttrOrigin DiffItemTargetFieldInfo = DiffItem + attrGet _ = getDiffItemTarget + attrSet _ = setDiffItemTarget + attrConstruct = undefined + attrClear _ = clearDiffItemTarget + +diffItem_target :: AttrLabelProxy "target" +diffItem_target = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@src_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #srcInfo +@ +-} +getDiffItemSrcInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo) +getDiffItemSrcInfo s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (Ptr Gio.FileInfo.FileInfo) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Gio.FileInfo.FileInfo) val' + return val'' + return result + +{- | +Set the value of the “@src_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #srcInfo 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemSrcInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m () +setDiffItemSrcInfo s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Ptr Gio.FileInfo.FileInfo) + +{- | +Set the value of the “@src_info@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #srcInfo +@ +-} +clearDiffItemSrcInfo :: MonadIO m => DiffItem -> m () +clearDiffItemSrcInfo s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Gio.FileInfo.FileInfo) + +#if ENABLE_OVERLOADING +data DiffItemSrcInfoFieldInfo +instance AttrInfo DiffItemSrcInfoFieldInfo where + type AttrAllowedOps DiffItemSrcInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemSrcInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo) + type AttrBaseTypeConstraint DiffItemSrcInfoFieldInfo = (~) DiffItem + type AttrGetType DiffItemSrcInfoFieldInfo = Maybe Gio.FileInfo.FileInfo + type AttrLabel DiffItemSrcInfoFieldInfo = "src_info" + type AttrOrigin DiffItemSrcInfoFieldInfo = DiffItem + attrGet _ = getDiffItemSrcInfo + attrSet _ = setDiffItemSrcInfo + attrConstruct = undefined + attrClear _ = clearDiffItemSrcInfo + +diffItem_srcInfo :: AttrLabelProxy "srcInfo" +diffItem_srcInfo = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@target_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #targetInfo +@ +-} +getDiffItemTargetInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo) +getDiffItemTargetInfo s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (Ptr Gio.FileInfo.FileInfo) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Gio.FileInfo.FileInfo) val' + return val'' + return result + +{- | +Set the value of the “@target_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #targetInfo 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemTargetInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m () +setDiffItemTargetInfo s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Ptr Gio.FileInfo.FileInfo) + +{- | +Set the value of the “@target_info@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #targetInfo +@ +-} +clearDiffItemTargetInfo :: MonadIO m => DiffItem -> m () +clearDiffItemTargetInfo s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Gio.FileInfo.FileInfo) + +#if ENABLE_OVERLOADING +data DiffItemTargetInfoFieldInfo +instance AttrInfo DiffItemTargetInfoFieldInfo where + type AttrAllowedOps DiffItemTargetInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemTargetInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo) + type AttrBaseTypeConstraint DiffItemTargetInfoFieldInfo = (~) DiffItem + type AttrGetType DiffItemTargetInfoFieldInfo = Maybe Gio.FileInfo.FileInfo + type AttrLabel DiffItemTargetInfoFieldInfo = "target_info" + type AttrOrigin DiffItemTargetInfoFieldInfo = DiffItem + attrGet _ = getDiffItemTargetInfo + attrSet _ = setDiffItemTargetInfo + attrConstruct = undefined + attrClear _ = clearDiffItemTargetInfo + +diffItem_targetInfo :: AttrLabelProxy "targetInfo" +diffItem_targetInfo = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@src_checksum@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #srcChecksum +@ +-} +getDiffItemSrcChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text) +getDiffItemSrcChecksum s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@src_checksum@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #srcChecksum 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemSrcChecksum :: MonadIO m => DiffItem -> CString -> m () +setDiffItemSrcChecksum s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: CString) + +{- | +Set the value of the “@src_checksum@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #srcChecksum +@ +-} +clearDiffItemSrcChecksum :: MonadIO m => DiffItem -> m () +clearDiffItemSrcChecksum s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data DiffItemSrcChecksumFieldInfo +instance AttrInfo DiffItemSrcChecksumFieldInfo where + type AttrAllowedOps DiffItemSrcChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemSrcChecksumFieldInfo = (~) CString + type AttrBaseTypeConstraint DiffItemSrcChecksumFieldInfo = (~) DiffItem + type AttrGetType DiffItemSrcChecksumFieldInfo = Maybe T.Text + type AttrLabel DiffItemSrcChecksumFieldInfo = "src_checksum" + type AttrOrigin DiffItemSrcChecksumFieldInfo = DiffItem + attrGet _ = getDiffItemSrcChecksum + attrSet _ = setDiffItemSrcChecksum + attrConstruct = undefined + attrClear _ = clearDiffItemSrcChecksum + +diffItem_srcChecksum :: AttrLabelProxy "srcChecksum" +diffItem_srcChecksum = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@target_checksum@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffItem #targetChecksum +@ +-} +getDiffItemTargetChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text) +getDiffItemTargetChecksum s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@target_checksum@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffItem [ #targetChecksum 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffItemTargetChecksum :: MonadIO m => DiffItem -> CString -> m () +setDiffItemTargetChecksum s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: CString) + +{- | +Set the value of the “@target_checksum@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #targetChecksum +@ +-} +clearDiffItemTargetChecksum :: MonadIO m => DiffItem -> m () +clearDiffItemTargetChecksum s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data DiffItemTargetChecksumFieldInfo +instance AttrInfo DiffItemTargetChecksumFieldInfo where + type AttrAllowedOps DiffItemTargetChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffItemTargetChecksumFieldInfo = (~) CString + type AttrBaseTypeConstraint DiffItemTargetChecksumFieldInfo = (~) DiffItem + type AttrGetType DiffItemTargetChecksumFieldInfo = Maybe T.Text + type AttrLabel DiffItemTargetChecksumFieldInfo = "target_checksum" + type AttrOrigin DiffItemTargetChecksumFieldInfo = DiffItem + attrGet _ = getDiffItemTargetChecksum + attrSet _ = setDiffItemTargetChecksum + attrConstruct = undefined + attrClear _ = clearDiffItemTargetChecksum + +diffItem_targetChecksum :: AttrLabelProxy "targetChecksum" +diffItem_targetChecksum = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffItem +type instance O.AttributeList DiffItem = DiffItemAttributeList +type DiffItemAttributeList = ('[ '("refcount", DiffItemRefcountFieldInfo), '("src", DiffItemSrcFieldInfo), '("target", DiffItemTargetFieldInfo), '("srcInfo", DiffItemSrcInfoFieldInfo), '("targetInfo", DiffItemTargetInfoFieldInfo), '("srcChecksum", DiffItemSrcChecksumFieldInfo), '("targetChecksum", DiffItemTargetChecksumFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method DiffItem::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diffitem", argType = TInterface (Name {namespace = "OSTree", name = "DiffItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "DiffItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_diff_item_ref" ostree_diff_item_ref :: + Ptr DiffItem -> -- diffitem : TInterface (Name {namespace = "OSTree", name = "DiffItem"}) + IO (Ptr DiffItem) + +{- | +/No description available in the introspection data./ +-} +diffItemRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffItem + -> m DiffItem +diffItemRef diffitem = liftIO $ do + diffitem' <- unsafeManagedPtrGetPtr diffitem + result <- ostree_diff_item_ref diffitem' + checkUnexpectedReturnNULL "diffItemRef" result + result' <- (wrapBoxed DiffItem) result + touchManagedPtr diffitem + return result' + +#if ENABLE_OVERLOADING +data DiffItemRefMethodInfo +instance (signature ~ (m DiffItem), MonadIO m) => O.MethodInfo DiffItemRefMethodInfo DiffItem signature where + overloadedMethod _ = diffItemRef + +#endif + +-- method DiffItem::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diffitem", argType = TInterface (Name {namespace = "OSTree", name = "DiffItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_diff_item_unref" ostree_diff_item_unref :: + Ptr DiffItem -> -- diffitem : TInterface (Name {namespace = "OSTree", name = "DiffItem"}) + IO () + +{- | +/No description available in the introspection data./ +-} +diffItemUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffItem + -> m () +diffItemUnref diffitem = liftIO $ do + diffitem' <- unsafeManagedPtrGetPtr diffitem + ostree_diff_item_unref diffitem' + touchManagedPtr diffitem + return () + +#if ENABLE_OVERLOADING +data DiffItemUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffItemUnrefMethodInfo DiffItem signature where + overloadedMethod _ = diffItemUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffItemMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffItemMethod "ref" o = DiffItemRefMethodInfo + ResolveDiffItemMethod "unref" o = DiffItemUnrefMethodInfo + ResolveDiffItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffItemMethod t DiffItem, O.MethodInfo info DiffItem p) => OL.IsLabel t (DiffItem -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/DiffItem.hs-boot b/GI/OSTree/Structs/DiffItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/DiffItem.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.DiffItem 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype DiffItem = DiffItem (ManagedPtr DiffItem) +instance BoxedObject DiffItem where +#if ENABLE_OVERLOADING +data DiffItemRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffItemUnrefMethodInfo +#endif diff --git a/GI/OSTree/Structs/GpgVerifier.hs b/GI/OSTree/Structs/GpgVerifier.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/GpgVerifier.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.GpgVerifier + ( + +-- * Exported types + GpgVerifier(..) , + noGpgVerifier , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype GpgVerifier = GpgVerifier (ManagedPtr GpgVerifier) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr GpgVerifier where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `GpgVerifier`. +noGpgVerifier :: Maybe GpgVerifier +noGpgVerifier = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GpgVerifier +type instance O.AttributeList GpgVerifier = GpgVerifierAttributeList +type GpgVerifierAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveGpgVerifierMethod (t :: Symbol) (o :: *) :: * where + ResolveGpgVerifierMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGpgVerifierMethod t GpgVerifier, O.MethodInfo info GpgVerifier p) => OL.IsLabel t (GpgVerifier -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/GpgVerifier.hs-boot b/GI/OSTree/Structs/GpgVerifier.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/GpgVerifier.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.GpgVerifier 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype GpgVerifier = GpgVerifier (ManagedPtr GpgVerifier) +instance WrappedPtr GpgVerifier where diff --git a/GI/OSTree/Structs/LibarchiveInputStream.hs b/GI/OSTree/Structs/LibarchiveInputStream.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LibarchiveInputStream.hs @@ -0,0 +1,163 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.LibarchiveInputStream + ( + +-- * Exported types + LibarchiveInputStream(..) , + newZeroLibarchiveInputStream , + noLibarchiveInputStream , + + + -- * Properties +-- ** parentInstance #attr:parentInstance# +{- | /No description available in the introspection data./ +-} + clearLibarchiveInputStreamParentInstance, + getLibarchiveInputStreamParentInstance , +#if ENABLE_OVERLOADING + libarchiveInputStream_parentInstance , +#endif + setLibarchiveInputStreamParentInstance , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.Gio.Objects.InputStream as Gio.InputStream + +-- | Memory-managed wrapper type. +newtype LibarchiveInputStream = LibarchiveInputStream (ManagedPtr LibarchiveInputStream) +instance WrappedPtr LibarchiveInputStream where + wrappedPtrCalloc = callocBytes 40 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr LibarchiveInputStream) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `LibarchiveInputStream` struct initialized to zero. +newZeroLibarchiveInputStream :: MonadIO m => m LibarchiveInputStream +newZeroLibarchiveInputStream = liftIO $ wrappedPtrCalloc >>= wrapPtr LibarchiveInputStream + +instance tag ~ 'AttrSet => Constructible LibarchiveInputStream tag where + new _ attrs = do + o <- newZeroLibarchiveInputStream + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `LibarchiveInputStream`. +noLibarchiveInputStream :: Maybe LibarchiveInputStream +noLibarchiveInputStream = Nothing + +{- | +Get the value of the “@parent_instance@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' libarchiveInputStream #parentInstance +@ +-} +getLibarchiveInputStreamParentInstance :: MonadIO m => LibarchiveInputStream -> m (Maybe Gio.InputStream.InputStream) +getLibarchiveInputStreamParentInstance s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gio.InputStream.InputStream) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Gio.InputStream.InputStream) val' + return val'' + return result + +{- | +Set the value of the “@parent_instance@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' libarchiveInputStream [ #parentInstance 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setLibarchiveInputStreamParentInstance :: MonadIO m => LibarchiveInputStream -> Ptr Gio.InputStream.InputStream -> m () +setLibarchiveInputStreamParentInstance s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr Gio.InputStream.InputStream) + +{- | +Set the value of the “@parent_instance@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #parentInstance +@ +-} +clearLibarchiveInputStreamParentInstance :: MonadIO m => LibarchiveInputStream -> m () +clearLibarchiveInputStreamParentInstance s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Gio.InputStream.InputStream) + +#if ENABLE_OVERLOADING +data LibarchiveInputStreamParentInstanceFieldInfo +instance AttrInfo LibarchiveInputStreamParentInstanceFieldInfo where + type AttrAllowedOps LibarchiveInputStreamParentInstanceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LibarchiveInputStreamParentInstanceFieldInfo = (~) (Ptr Gio.InputStream.InputStream) + type AttrBaseTypeConstraint LibarchiveInputStreamParentInstanceFieldInfo = (~) LibarchiveInputStream + type AttrGetType LibarchiveInputStreamParentInstanceFieldInfo = Maybe Gio.InputStream.InputStream + type AttrLabel LibarchiveInputStreamParentInstanceFieldInfo = "parent_instance" + type AttrOrigin LibarchiveInputStreamParentInstanceFieldInfo = LibarchiveInputStream + attrGet _ = getLibarchiveInputStreamParentInstance + attrSet _ = setLibarchiveInputStreamParentInstance + attrConstruct = undefined + attrClear _ = clearLibarchiveInputStreamParentInstance + +libarchiveInputStream_parentInstance :: AttrLabelProxy "parentInstance" +libarchiveInputStream_parentInstance = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LibarchiveInputStream +type instance O.AttributeList LibarchiveInputStream = LibarchiveInputStreamAttributeList +type LibarchiveInputStreamAttributeList = ('[ '("parentInstance", LibarchiveInputStreamParentInstanceFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveLibarchiveInputStreamMethod (t :: Symbol) (o :: *) :: * where + ResolveLibarchiveInputStreamMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLibarchiveInputStreamMethod t LibarchiveInputStream, O.MethodInfo info LibarchiveInputStream p) => OL.IsLabel t (LibarchiveInputStream -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/LibarchiveInputStream.hs-boot b/GI/OSTree/Structs/LibarchiveInputStream.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LibarchiveInputStream.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.LibarchiveInputStream 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype LibarchiveInputStream = LibarchiveInputStream (ManagedPtr LibarchiveInputStream) +instance WrappedPtr LibarchiveInputStream where diff --git a/GI/OSTree/Structs/LzmaCompressor.hs b/GI/OSTree/Structs/LzmaCompressor.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LzmaCompressor.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Zlib decompression +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.LzmaCompressor + ( + +-- * Exported types + LzmaCompressor(..) , + noLzmaCompressor , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype LzmaCompressor = LzmaCompressor (ManagedPtr LzmaCompressor) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr LzmaCompressor where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `LzmaCompressor`. +noLzmaCompressor :: Maybe LzmaCompressor +noLzmaCompressor = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LzmaCompressor +type instance O.AttributeList LzmaCompressor = LzmaCompressorAttributeList +type LzmaCompressorAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveLzmaCompressorMethod (t :: Symbol) (o :: *) :: * where + ResolveLzmaCompressorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLzmaCompressorMethod t LzmaCompressor, O.MethodInfo info LzmaCompressor p) => OL.IsLabel t (LzmaCompressor -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/LzmaCompressor.hs-boot b/GI/OSTree/Structs/LzmaCompressor.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LzmaCompressor.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.LzmaCompressor 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype LzmaCompressor = LzmaCompressor (ManagedPtr LzmaCompressor) +instance WrappedPtr LzmaCompressor where diff --git a/GI/OSTree/Structs/LzmaDecompressor.hs b/GI/OSTree/Structs/LzmaDecompressor.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LzmaDecompressor.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.LzmaDecompressor + ( + +-- * Exported types + LzmaDecompressor(..) , + noLzmaDecompressor , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype LzmaDecompressor = LzmaDecompressor (ManagedPtr LzmaDecompressor) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr LzmaDecompressor where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `LzmaDecompressor`. +noLzmaDecompressor :: Maybe LzmaDecompressor +noLzmaDecompressor = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LzmaDecompressor +type instance O.AttributeList LzmaDecompressor = LzmaDecompressorAttributeList +type LzmaDecompressorAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveLzmaDecompressorMethod (t :: Symbol) (o :: *) :: * where + ResolveLzmaDecompressorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLzmaDecompressorMethod t LzmaDecompressor, O.MethodInfo info LzmaDecompressor p) => OL.IsLabel t (LzmaDecompressor -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/LzmaDecompressor.hs-boot b/GI/OSTree/Structs/LzmaDecompressor.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/LzmaDecompressor.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.LzmaDecompressor 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype LzmaDecompressor = LzmaDecompressor (ManagedPtr LzmaDecompressor) +instance WrappedPtr LzmaDecompressor where diff --git a/GI/OSTree/Structs/MutableTreeIter.hs b/GI/OSTree/Structs/MutableTreeIter.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/MutableTreeIter.hs @@ -0,0 +1,192 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.MutableTreeIter + ( + +-- * Exported types + MutableTreeIter(..) , + newZeroMutableTreeIter , + noMutableTreeIter , + + + -- * Properties +-- ** inFiles #attr:inFiles# +{- | /No description available in the introspection data./ +-} + getMutableTreeIterInFiles , +#if ENABLE_OVERLOADING + mutableTreeIter_inFiles , +#endif + setMutableTreeIterInFiles , + + +-- ** iter #attr:iter# +{- | /No description available in the introspection data./ +-} + getMutableTreeIterIter , +#if ENABLE_OVERLOADING + mutableTreeIter_iter , +#endif + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Structs.HashTableIter as GLib.HashTableIter + +-- | Memory-managed wrapper type. +newtype MutableTreeIter = MutableTreeIter (ManagedPtr MutableTreeIter) +instance WrappedPtr MutableTreeIter where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr MutableTreeIter) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `MutableTreeIter` struct initialized to zero. +newZeroMutableTreeIter :: MonadIO m => m MutableTreeIter +newZeroMutableTreeIter = liftIO $ wrappedPtrCalloc >>= wrapPtr MutableTreeIter + +instance tag ~ 'AttrSet => Constructible MutableTreeIter tag where + new _ attrs = do + o <- newZeroMutableTreeIter + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `MutableTreeIter`. +noMutableTreeIter :: Maybe MutableTreeIter +noMutableTreeIter = Nothing + +{- | +Get the value of the “@in_files@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' mutableTreeIter #inFiles +@ +-} +getMutableTreeIterInFiles :: MonadIO m => MutableTreeIter -> m Bool +getMutableTreeIterInFiles s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@in_files@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' mutableTreeIter [ #inFiles 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMutableTreeIterInFiles :: MonadIO m => MutableTreeIter -> Bool -> m () +setMutableTreeIterInFiles s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CInt) + +#if ENABLE_OVERLOADING +data MutableTreeIterInFilesFieldInfo +instance AttrInfo MutableTreeIterInFilesFieldInfo where + type AttrAllowedOps MutableTreeIterInFilesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint MutableTreeIterInFilesFieldInfo = (~) Bool + type AttrBaseTypeConstraint MutableTreeIterInFilesFieldInfo = (~) MutableTreeIter + type AttrGetType MutableTreeIterInFilesFieldInfo = Bool + type AttrLabel MutableTreeIterInFilesFieldInfo = "in_files" + type AttrOrigin MutableTreeIterInFilesFieldInfo = MutableTreeIter + attrGet _ = getMutableTreeIterInFiles + attrSet _ = setMutableTreeIterInFiles + attrConstruct = undefined + attrClear _ = undefined + +mutableTreeIter_inFiles :: AttrLabelProxy "inFiles" +mutableTreeIter_inFiles = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@iter@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' mutableTreeIter #iter +@ +-} +getMutableTreeIterIter :: MonadIO m => MutableTreeIter -> m GLib.HashTableIter.HashTableIter +getMutableTreeIterIter s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 8 :: (Ptr GLib.HashTableIter.HashTableIter) + val' <- (newPtr GLib.HashTableIter.HashTableIter) val + return val' + +#if ENABLE_OVERLOADING +data MutableTreeIterIterFieldInfo +instance AttrInfo MutableTreeIterIterFieldInfo where + type AttrAllowedOps MutableTreeIterIterFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint MutableTreeIterIterFieldInfo = (~) (Ptr GLib.HashTableIter.HashTableIter) + type AttrBaseTypeConstraint MutableTreeIterIterFieldInfo = (~) MutableTreeIter + type AttrGetType MutableTreeIterIterFieldInfo = GLib.HashTableIter.HashTableIter + type AttrLabel MutableTreeIterIterFieldInfo = "iter" + type AttrOrigin MutableTreeIterIterFieldInfo = MutableTreeIter + attrGet _ = getMutableTreeIterIter + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +mutableTreeIter_iter :: AttrLabelProxy "iter" +mutableTreeIter_iter = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList MutableTreeIter +type instance O.AttributeList MutableTreeIter = MutableTreeIterAttributeList +type MutableTreeIterAttributeList = ('[ '("inFiles", MutableTreeIterInFilesFieldInfo), '("iter", MutableTreeIterIterFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveMutableTreeIterMethod (t :: Symbol) (o :: *) :: * where + ResolveMutableTreeIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMutableTreeIterMethod t MutableTreeIter, O.MethodInfo info MutableTreeIter p) => OL.IsLabel t (MutableTreeIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/MutableTreeIter.hs-boot b/GI/OSTree/Structs/MutableTreeIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/MutableTreeIter.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.MutableTreeIter 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype MutableTreeIter = MutableTreeIter (ManagedPtr MutableTreeIter) +instance WrappedPtr MutableTreeIter where diff --git a/GI/OSTree/Structs/Remote.hs b/GI/OSTree/Structs/Remote.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/Remote.hs @@ -0,0 +1,273 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +This represents the configuration for a single remote repository. Currently, +remotes can only be passed around as (reference counted) opaque handles. In +future, more API may be added to create and interrogate them. + +/Since: 2018.6/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.Remote + ( + +-- * Exported types + Remote(..) , + noRemote , + + + -- * Methods +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + RemoteGetNameMethodInfo , +#endif + remoteGetName , + + +-- ** getUrl #method:getUrl# + +#if ENABLE_OVERLOADING + RemoteGetUrlMethodInfo , +#endif + remoteGetUrl , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RemoteRefMethodInfo , +#endif + remoteRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RemoteUnrefMethodInfo , +#endif + remoteUnref , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype Remote = Remote (ManagedPtr Remote) +foreign import ccall "ostree_remote_get_type" c_ostree_remote_get_type :: + IO GType + +instance BoxedObject Remote where + boxedType _ = c_ostree_remote_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Remote`. +noRemote :: Maybe Remote +noRemote = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Remote +type instance O.AttributeList Remote = RemoteAttributeList +type RemoteAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Remote::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "OSTree", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRemote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_remote_get_name" ostree_remote_get_name :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "OSTree", name = "Remote"}) + IO CString + +{- | +Get the human-readable name of the remote. This is what the user configured, +if the remote was explicitly configured; and will otherwise be a stable, +arbitrary, string. + +/Since: 2018.6/ +-} +remoteGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + Remote + {- ^ /@remote@/: an 'GI.OSTree.Structs.Remote.Remote' -} + -> m T.Text + {- ^ __Returns:__ remote’s name -} +remoteGetName remote = liftIO $ do + remote' <- unsafeManagedPtrGetPtr remote + result <- ostree_remote_get_name remote' + checkUnexpectedReturnNULL "remoteGetName" result + result' <- cstringToText result + touchManagedPtr remote + return result' + +#if ENABLE_OVERLOADING +data RemoteGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo RemoteGetNameMethodInfo Remote signature where + overloadedMethod _ = remoteGetName + +#endif + +-- method Remote::get_url +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "OSTree", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRemote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_remote_get_url" ostree_remote_get_url :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "OSTree", name = "Remote"}) + IO CString + +{- | +Get the URL from the remote. + +/Since: 2018.6/ +-} +remoteGetUrl :: + (B.CallStack.HasCallStack, MonadIO m) => + Remote + {- ^ /@remote@/: an 'GI.OSTree.Structs.Remote.Remote' -} + -> m T.Text + {- ^ __Returns:__ the remote\'s URL -} +remoteGetUrl remote = liftIO $ do + remote' <- unsafeManagedPtrGetPtr remote + result <- ostree_remote_get_url remote' + checkUnexpectedReturnNULL "remoteGetUrl" result + result' <- cstringToText result + freeMem result + touchManagedPtr remote + return result' + +#if ENABLE_OVERLOADING +data RemoteGetUrlMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo RemoteGetUrlMethodInfo Remote signature where + overloadedMethod _ = remoteGetUrl + +#endif + +-- method Remote::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "OSTree", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRemote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Remote"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_remote_ref" ostree_remote_ref :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "OSTree", name = "Remote"}) + IO (Ptr Remote) + +{- | +Increase the reference count on the given /@remote@/. + +/Since: 2018.6/ +-} +remoteRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Remote + {- ^ /@remote@/: an 'GI.OSTree.Structs.Remote.Remote' -} + -> m Remote + {- ^ __Returns:__ a copy of /@remote@/, for convenience -} +remoteRef remote = liftIO $ do + remote' <- unsafeManagedPtrGetPtr remote + result <- ostree_remote_ref remote' + checkUnexpectedReturnNULL "remoteRef" result + result' <- (wrapBoxed Remote) result + touchManagedPtr remote + return result' + +#if ENABLE_OVERLOADING +data RemoteRefMethodInfo +instance (signature ~ (m Remote), MonadIO m) => O.MethodInfo RemoteRefMethodInfo Remote signature where + overloadedMethod _ = remoteRef + +#endif + +-- method Remote::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "OSTree", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRemote", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_remote_unref" ostree_remote_unref :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "OSTree", name = "Remote"}) + IO () + +{- | +Decrease the reference count on the given /@remote@/ and free it if the +reference count reaches 0. + +/Since: 2018.6/ +-} +remoteUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Remote + {- ^ /@remote@/: an 'GI.OSTree.Structs.Remote.Remote' -} + -> m () +remoteUnref remote = liftIO $ do + remote' <- B.ManagedPtr.disownBoxed remote + ostree_remote_unref remote' + touchManagedPtr remote + return () + +#if ENABLE_OVERLOADING +data RemoteUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RemoteUnrefMethodInfo Remote signature where + overloadedMethod _ = remoteUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRemoteMethod (t :: Symbol) (o :: *) :: * where + ResolveRemoteMethod "ref" o = RemoteRefMethodInfo + ResolveRemoteMethod "unref" o = RemoteUnrefMethodInfo + ResolveRemoteMethod "getName" o = RemoteGetNameMethodInfo + ResolveRemoteMethod "getUrl" o = RemoteGetUrlMethodInfo + ResolveRemoteMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRemoteMethod t Remote, O.MethodInfo info Remote p) => OL.IsLabel t (Remote -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/Remote.hs-boot b/GI/OSTree/Structs/Remote.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/Remote.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.Remote 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype Remote = Remote (ManagedPtr Remote) +instance BoxedObject Remote where +#if ENABLE_OVERLOADING +data RemoteGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetUrlMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteUnrefMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoCheckoutAtOptions.hs b/GI/OSTree/Structs/RepoCheckoutAtOptions.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCheckoutAtOptions.hs @@ -0,0 +1,1096 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An extensible options structure controlling checkout. Ensure that +you have entirely zeroed the structure, then set just the desired +options. This is used by 'GI.OSTree.Objects.Repo.repoCheckoutAt' which +supercedes previous separate enumeration usage in +'GI.OSTree.Objects.Repo.repoCheckoutTree' and @/ostree_repo_checkout_tree_at()/@. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoCheckoutAtOptions + ( + +-- * Exported types + RepoCheckoutAtOptions(..) , + newZeroRepoCheckoutAtOptions , + noRepoCheckoutAtOptions , + + + -- * Methods +-- ** setDevino #method:setDevino# + +#if ENABLE_OVERLOADING + RepoCheckoutAtOptionsSetDevinoMethodInfo, +#endif + repoCheckoutAtOptionsSetDevino , + + + + + -- * Properties +-- ** bareuseronlyDirs #attr:bareuseronlyDirs# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsBareuseronlyDirs, +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_bareuseronlyDirs , +#endif + setRepoCheckoutAtOptionsBareuseronlyDirs, + + +-- ** devinoToCsumCache #attr:devinoToCsumCache# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsDevinoToCsumCache, + getRepoCheckoutAtOptionsDevinoToCsumCache, +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_devinoToCsumCache , +#endif + setRepoCheckoutAtOptionsDevinoToCsumCache, + + +-- ** enableFsync #attr:enableFsync# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsEnableFsync , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_enableFsync , +#endif + setRepoCheckoutAtOptionsEnableFsync , + + +-- ** enableUncompressedCache #attr:enableUncompressedCache# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsEnableUncompressedCache, +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_enableUncompressedCache, +#endif + setRepoCheckoutAtOptionsEnableUncompressedCache, + + +-- ** filter #attr:filter# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsFilter , + getRepoCheckoutAtOptionsFilter , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_filter , +#endif + setRepoCheckoutAtOptionsFilter , + + +-- ** filterUserData #attr:filterUserData# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsFilterUserData, + getRepoCheckoutAtOptionsFilterUserData , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_filterUserData , +#endif + setRepoCheckoutAtOptionsFilterUserData , + + +-- ** forceCopy #attr:forceCopy# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsForceCopy , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_forceCopy , +#endif + setRepoCheckoutAtOptionsForceCopy , + + +-- ** forceCopyZerosized #attr:forceCopyZerosized# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsForceCopyZerosized, +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_forceCopyZerosized, +#endif + setRepoCheckoutAtOptionsForceCopyZerosized, + + +-- ** mode #attr:mode# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsMode , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_mode , +#endif + setRepoCheckoutAtOptionsMode , + + +-- ** noCopyFallback #attr:noCopyFallback# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsNoCopyFallback , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_noCopyFallback , +#endif + setRepoCheckoutAtOptionsNoCopyFallback , + + +-- ** overwriteMode #attr:overwriteMode# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsOverwriteMode , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_overwriteMode , +#endif + setRepoCheckoutAtOptionsOverwriteMode , + + +-- ** processWhiteouts #attr:processWhiteouts# +{- | /No description available in the introspection data./ +-} + getRepoCheckoutAtOptionsProcessWhiteouts, +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_processWhiteouts , +#endif + setRepoCheckoutAtOptionsProcessWhiteouts, + + +-- ** sepolicy #attr:sepolicy# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsSepolicy , + getRepoCheckoutAtOptionsSepolicy , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_sepolicy , +#endif + setRepoCheckoutAtOptionsSepolicy , + + +-- ** sepolicyPrefix #attr:sepolicyPrefix# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsSepolicyPrefix, + getRepoCheckoutAtOptionsSepolicyPrefix , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_sepolicyPrefix , +#endif + setRepoCheckoutAtOptionsSepolicyPrefix , + + +-- ** subpath #attr:subpath# +{- | /No description available in the introspection data./ +-} + clearRepoCheckoutAtOptionsSubpath , + getRepoCheckoutAtOptionsSubpath , +#if ENABLE_OVERLOADING + repoCheckoutAtOptions_subpath , +#endif + setRepoCheckoutAtOptionsSubpath , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.OSTree.Callbacks as OSTree.Callbacks +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Objects.SePolicy as OSTree.SePolicy +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache + +-- | Memory-managed wrapper type. +newtype RepoCheckoutAtOptions = RepoCheckoutAtOptions (ManagedPtr RepoCheckoutAtOptions) +instance WrappedPtr RepoCheckoutAtOptions where + wrappedPtrCalloc = callocBytes 152 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 152 >=> wrapPtr RepoCheckoutAtOptions) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `RepoCheckoutAtOptions` struct initialized to zero. +newZeroRepoCheckoutAtOptions :: MonadIO m => m RepoCheckoutAtOptions +newZeroRepoCheckoutAtOptions = liftIO $ wrappedPtrCalloc >>= wrapPtr RepoCheckoutAtOptions + +instance tag ~ 'AttrSet => Constructible RepoCheckoutAtOptions tag where + new _ attrs = do + o <- newZeroRepoCheckoutAtOptions + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoCheckoutAtOptions`. +noRepoCheckoutAtOptions :: Maybe RepoCheckoutAtOptions +noRepoCheckoutAtOptions = Nothing + +{- | +Get the value of the “@mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #mode +@ +-} +getRepoCheckoutAtOptionsMode :: MonadIO m => RepoCheckoutAtOptions -> m OSTree.Enums.RepoCheckoutMode +getRepoCheckoutAtOptionsMode s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #mode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsMode :: MonadIO m => RepoCheckoutAtOptions -> OSTree.Enums.RepoCheckoutMode -> m () +setRepoCheckoutAtOptionsMode s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsModeFieldInfo +instance AttrInfo RepoCheckoutAtOptionsModeFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsModeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsModeFieldInfo = (~) OSTree.Enums.RepoCheckoutMode + type AttrBaseTypeConstraint RepoCheckoutAtOptionsModeFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsModeFieldInfo = OSTree.Enums.RepoCheckoutMode + type AttrLabel RepoCheckoutAtOptionsModeFieldInfo = "mode" + type AttrOrigin RepoCheckoutAtOptionsModeFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsMode + attrSet _ = setRepoCheckoutAtOptionsMode + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_mode :: AttrLabelProxy "mode" +repoCheckoutAtOptions_mode = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@overwrite_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #overwriteMode +@ +-} +getRepoCheckoutAtOptionsOverwriteMode :: MonadIO m => RepoCheckoutAtOptions -> m OSTree.Enums.RepoCheckoutOverwriteMode +getRepoCheckoutAtOptionsOverwriteMode s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@overwrite_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #overwriteMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsOverwriteMode :: MonadIO m => RepoCheckoutAtOptions -> OSTree.Enums.RepoCheckoutOverwriteMode -> m () +setRepoCheckoutAtOptionsOverwriteMode s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 4) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsOverwriteModeFieldInfo +instance AttrInfo RepoCheckoutAtOptionsOverwriteModeFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsOverwriteModeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsOverwriteModeFieldInfo = (~) OSTree.Enums.RepoCheckoutOverwriteMode + type AttrBaseTypeConstraint RepoCheckoutAtOptionsOverwriteModeFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsOverwriteModeFieldInfo = OSTree.Enums.RepoCheckoutOverwriteMode + type AttrLabel RepoCheckoutAtOptionsOverwriteModeFieldInfo = "overwrite_mode" + type AttrOrigin RepoCheckoutAtOptionsOverwriteModeFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsOverwriteMode + attrSet _ = setRepoCheckoutAtOptionsOverwriteMode + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_overwriteMode :: AttrLabelProxy "overwriteMode" +repoCheckoutAtOptions_overwriteMode = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@enable_uncompressed_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #enableUncompressedCache +@ +-} +getRepoCheckoutAtOptionsEnableUncompressedCache :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsEnableUncompressedCache s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@enable_uncompressed_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #enableUncompressedCache 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsEnableUncompressedCache :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsEnableUncompressedCache s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 8) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo +instance AttrInfo RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = "enable_uncompressed_cache" + type AttrOrigin RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsEnableUncompressedCache + attrSet _ = setRepoCheckoutAtOptionsEnableUncompressedCache + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_enableUncompressedCache :: AttrLabelProxy "enableUncompressedCache" +repoCheckoutAtOptions_enableUncompressedCache = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@enable_fsync@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #enableFsync +@ +-} +getRepoCheckoutAtOptionsEnableFsync :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsEnableFsync s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@enable_fsync@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #enableFsync 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsEnableFsync :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsEnableFsync s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 12) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsEnableFsyncFieldInfo +instance AttrInfo RepoCheckoutAtOptionsEnableFsyncFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsEnableFsyncFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsEnableFsyncFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsEnableFsyncFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsEnableFsyncFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsEnableFsyncFieldInfo = "enable_fsync" + type AttrOrigin RepoCheckoutAtOptionsEnableFsyncFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsEnableFsync + attrSet _ = setRepoCheckoutAtOptionsEnableFsync + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_enableFsync :: AttrLabelProxy "enableFsync" +repoCheckoutAtOptions_enableFsync = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@process_whiteouts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #processWhiteouts +@ +-} +getRepoCheckoutAtOptionsProcessWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsProcessWhiteouts s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@process_whiteouts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #processWhiteouts 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsProcessWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsProcessWhiteouts s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 16) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo +instance AttrInfo RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = "process_whiteouts" + type AttrOrigin RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsProcessWhiteouts + attrSet _ = setRepoCheckoutAtOptionsProcessWhiteouts + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_processWhiteouts :: AttrLabelProxy "processWhiteouts" +repoCheckoutAtOptions_processWhiteouts = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@no_copy_fallback@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #noCopyFallback +@ +-} +getRepoCheckoutAtOptionsNoCopyFallback :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsNoCopyFallback s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@no_copy_fallback@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #noCopyFallback 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsNoCopyFallback :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsNoCopyFallback s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 20) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsNoCopyFallbackFieldInfo +instance AttrInfo RepoCheckoutAtOptionsNoCopyFallbackFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = "no_copy_fallback" + type AttrOrigin RepoCheckoutAtOptionsNoCopyFallbackFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsNoCopyFallback + attrSet _ = setRepoCheckoutAtOptionsNoCopyFallback + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_noCopyFallback :: AttrLabelProxy "noCopyFallback" +repoCheckoutAtOptions_noCopyFallback = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@force_copy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #forceCopy +@ +-} +getRepoCheckoutAtOptionsForceCopy :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsForceCopy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@force_copy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #forceCopy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsForceCopy :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsForceCopy s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 24) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsForceCopyFieldInfo +instance AttrInfo RepoCheckoutAtOptionsForceCopyFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsForceCopyFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsForceCopyFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsForceCopyFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsForceCopyFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsForceCopyFieldInfo = "force_copy" + type AttrOrigin RepoCheckoutAtOptionsForceCopyFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsForceCopy + attrSet _ = setRepoCheckoutAtOptionsForceCopy + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_forceCopy :: AttrLabelProxy "forceCopy" +repoCheckoutAtOptions_forceCopy = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@bareuseronly_dirs@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #bareuseronlyDirs +@ +-} +getRepoCheckoutAtOptionsBareuseronlyDirs :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsBareuseronlyDirs s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@bareuseronly_dirs@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #bareuseronlyDirs 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsBareuseronlyDirs :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsBareuseronlyDirs s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 28) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo +instance AttrInfo RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = "bareuseronly_dirs" + type AttrOrigin RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsBareuseronlyDirs + attrSet _ = setRepoCheckoutAtOptionsBareuseronlyDirs + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_bareuseronlyDirs :: AttrLabelProxy "bareuseronlyDirs" +repoCheckoutAtOptions_bareuseronlyDirs = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@force_copy_zerosized@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #forceCopyZerosized +@ +-} +getRepoCheckoutAtOptionsForceCopyZerosized :: MonadIO m => RepoCheckoutAtOptions -> m Bool +getRepoCheckoutAtOptionsForceCopyZerosized s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@force_copy_zerosized@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #forceCopyZerosized 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsForceCopyZerosized :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m () +setRepoCheckoutAtOptionsForceCopyZerosized s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 32) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo +instance AttrInfo RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = Bool + type AttrLabel RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = "force_copy_zerosized" + type AttrOrigin RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsForceCopyZerosized + attrSet _ = setRepoCheckoutAtOptionsForceCopyZerosized + attrConstruct = undefined + attrClear _ = undefined + +repoCheckoutAtOptions_forceCopyZerosized :: AttrLabelProxy "forceCopyZerosized" +repoCheckoutAtOptions_forceCopyZerosized = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoCheckoutAtOptions:unused_bools" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TBoolean)" +{- | +Get the value of the “@subpath@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #subpath +@ +-} +getRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe T.Text) +getRepoCheckoutAtOptionsSubpath s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@subpath@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #subpath 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> CString -> m () +setRepoCheckoutAtOptionsSubpath s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (val :: CString) + +{- | +Set the value of the “@subpath@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #subpath +@ +-} +clearRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsSubpath s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsSubpathFieldInfo +instance AttrInfo RepoCheckoutAtOptionsSubpathFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsSubpathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsSubpathFieldInfo = (~) CString + type AttrBaseTypeConstraint RepoCheckoutAtOptionsSubpathFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsSubpathFieldInfo = Maybe T.Text + type AttrLabel RepoCheckoutAtOptionsSubpathFieldInfo = "subpath" + type AttrOrigin RepoCheckoutAtOptionsSubpathFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsSubpath + attrSet _ = setRepoCheckoutAtOptionsSubpath + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsSubpath + +repoCheckoutAtOptions_subpath :: AttrLabelProxy "subpath" +repoCheckoutAtOptions_subpath = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@devino_to_csum_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #devinoToCsumCache +@ +-} +getRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe OSTree.RepoDevInoCache.RepoDevInoCache) +getRepoCheckoutAtOptionsDevinoToCsumCache s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 64) :: IO (Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed OSTree.RepoDevInoCache.RepoDevInoCache) val' + return val'' + return result + +{- | +Set the value of the “@devino_to_csum_cache@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #devinoToCsumCache 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> Ptr OSTree.RepoDevInoCache.RepoDevInoCache -> m () +setRepoCheckoutAtOptionsDevinoToCsumCache s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (val :: Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + +{- | +Set the value of the “@devino_to_csum_cache@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #devinoToCsumCache +@ +-} +clearRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsDevinoToCsumCache s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (FP.nullPtr :: Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo +instance AttrInfo RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = (~) (Ptr OSTree.RepoDevInoCache.RepoDevInoCache) + type AttrBaseTypeConstraint RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = Maybe OSTree.RepoDevInoCache.RepoDevInoCache + type AttrLabel RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = "devino_to_csum_cache" + type AttrOrigin RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsDevinoToCsumCache + attrSet _ = setRepoCheckoutAtOptionsDevinoToCsumCache + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsDevinoToCsumCache + +repoCheckoutAtOptions_devinoToCsumCache :: AttrLabelProxy "devinoToCsumCache" +repoCheckoutAtOptions_devinoToCsumCache = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoCheckoutAtOptions:unused_ints" :: Not implemented: "Don't know how to unpack C array of type TCArray False 6 (-1) (TBasicType TInt)" +-- XXX Skipped attribute for "RepoCheckoutAtOptions:unused_ptrs" :: Not implemented: "Don't know how to unpack C array of type TCArray False 3 (-1) (TBasicType TPtr)" +{- | +Get the value of the “@filter@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #filter +@ +-} +getRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe OSTree.Callbacks.RepoCheckoutFilter_WithClosures) +getRepoCheckoutAtOptionsFilter s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 120) :: IO (FunPtr OSTree.Callbacks.C_RepoCheckoutFilter) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = OSTree.Callbacks.dynamic_RepoCheckoutFilter val' + return val'' + return result + +{- | +Set the value of the “@filter@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #filter 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> FunPtr OSTree.Callbacks.C_RepoCheckoutFilter -> m () +setRepoCheckoutAtOptionsFilter s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 120) (val :: FunPtr OSTree.Callbacks.C_RepoCheckoutFilter) + +{- | +Set the value of the “@filter@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #filter +@ +-} +clearRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsFilter s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 120) (FP.nullFunPtr :: FunPtr OSTree.Callbacks.C_RepoCheckoutFilter) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsFilterFieldInfo +instance AttrInfo RepoCheckoutAtOptionsFilterFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsFilterFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsFilterFieldInfo = (~) (FunPtr OSTree.Callbacks.C_RepoCheckoutFilter) + type AttrBaseTypeConstraint RepoCheckoutAtOptionsFilterFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsFilterFieldInfo = Maybe OSTree.Callbacks.RepoCheckoutFilter_WithClosures + type AttrLabel RepoCheckoutAtOptionsFilterFieldInfo = "filter" + type AttrOrigin RepoCheckoutAtOptionsFilterFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsFilter + attrSet _ = setRepoCheckoutAtOptionsFilter + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsFilter + +repoCheckoutAtOptions_filter :: AttrLabelProxy "filter" +repoCheckoutAtOptions_filter = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@filter_user_data@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #filterUserData +@ +-} +getRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> m (Ptr ()) +getRepoCheckoutAtOptionsFilterUserData s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 128) :: IO (Ptr ()) + return val + +{- | +Set the value of the “@filter_user_data@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #filterUserData 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> Ptr () -> m () +setRepoCheckoutAtOptionsFilterUserData s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (val :: Ptr ()) + +{- | +Set the value of the “@filter_user_data@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #filterUserData +@ +-} +clearRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsFilterUserData s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (FP.nullPtr :: Ptr ()) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsFilterUserDataFieldInfo +instance AttrInfo RepoCheckoutAtOptionsFilterUserDataFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsFilterUserDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsFilterUserDataFieldInfo = (~) (Ptr ()) + type AttrBaseTypeConstraint RepoCheckoutAtOptionsFilterUserDataFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsFilterUserDataFieldInfo = Ptr () + type AttrLabel RepoCheckoutAtOptionsFilterUserDataFieldInfo = "filter_user_data" + type AttrOrigin RepoCheckoutAtOptionsFilterUserDataFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsFilterUserData + attrSet _ = setRepoCheckoutAtOptionsFilterUserData + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsFilterUserData + +repoCheckoutAtOptions_filterUserData :: AttrLabelProxy "filterUserData" +repoCheckoutAtOptions_filterUserData = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@sepolicy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #sepolicy +@ +-} +getRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe OSTree.SePolicy.SePolicy) +getRepoCheckoutAtOptionsSepolicy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 136) :: IO (Ptr OSTree.SePolicy.SePolicy) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject OSTree.SePolicy.SePolicy) val' + return val'' + return result + +{- | +Set the value of the “@sepolicy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #sepolicy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> Ptr OSTree.SePolicy.SePolicy -> m () +setRepoCheckoutAtOptionsSepolicy s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (val :: Ptr OSTree.SePolicy.SePolicy) + +{- | +Set the value of the “@sepolicy@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #sepolicy +@ +-} +clearRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsSepolicy s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (FP.nullPtr :: Ptr OSTree.SePolicy.SePolicy) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsSepolicyFieldInfo +instance AttrInfo RepoCheckoutAtOptionsSepolicyFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsSepolicyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsSepolicyFieldInfo = (~) (Ptr OSTree.SePolicy.SePolicy) + type AttrBaseTypeConstraint RepoCheckoutAtOptionsSepolicyFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsSepolicyFieldInfo = Maybe OSTree.SePolicy.SePolicy + type AttrLabel RepoCheckoutAtOptionsSepolicyFieldInfo = "sepolicy" + type AttrOrigin RepoCheckoutAtOptionsSepolicyFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsSepolicy + attrSet _ = setRepoCheckoutAtOptionsSepolicy + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsSepolicy + +repoCheckoutAtOptions_sepolicy :: AttrLabelProxy "sepolicy" +repoCheckoutAtOptions_sepolicy = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@sepolicy_prefix@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCheckoutAtOptions #sepolicyPrefix +@ +-} +getRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe T.Text) +getRepoCheckoutAtOptionsSepolicyPrefix s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 144) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@sepolicy_prefix@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCheckoutAtOptions [ #sepolicyPrefix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> CString -> m () +setRepoCheckoutAtOptionsSepolicyPrefix s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 144) (val :: CString) + +{- | +Set the value of the “@sepolicy_prefix@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #sepolicyPrefix +@ +-} +clearRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> m () +clearRepoCheckoutAtOptionsSepolicyPrefix s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 144) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsSepolicyPrefixFieldInfo +instance AttrInfo RepoCheckoutAtOptionsSepolicyPrefixFieldInfo where + type AttrAllowedOps RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = (~) CString + type AttrBaseTypeConstraint RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = (~) RepoCheckoutAtOptions + type AttrGetType RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = Maybe T.Text + type AttrLabel RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = "sepolicy_prefix" + type AttrOrigin RepoCheckoutAtOptionsSepolicyPrefixFieldInfo = RepoCheckoutAtOptions + attrGet _ = getRepoCheckoutAtOptionsSepolicyPrefix + attrSet _ = setRepoCheckoutAtOptionsSepolicyPrefix + attrConstruct = undefined + attrClear _ = clearRepoCheckoutAtOptionsSepolicyPrefix + +repoCheckoutAtOptions_sepolicyPrefix :: AttrLabelProxy "sepolicyPrefix" +repoCheckoutAtOptions_sepolicyPrefix = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoCheckoutAtOptions +type instance O.AttributeList RepoCheckoutAtOptions = RepoCheckoutAtOptionsAttributeList +type RepoCheckoutAtOptionsAttributeList = ('[ '("mode", RepoCheckoutAtOptionsModeFieldInfo), '("overwriteMode", RepoCheckoutAtOptionsOverwriteModeFieldInfo), '("enableUncompressedCache", RepoCheckoutAtOptionsEnableUncompressedCacheFieldInfo), '("enableFsync", RepoCheckoutAtOptionsEnableFsyncFieldInfo), '("processWhiteouts", RepoCheckoutAtOptionsProcessWhiteoutsFieldInfo), '("noCopyFallback", RepoCheckoutAtOptionsNoCopyFallbackFieldInfo), '("forceCopy", RepoCheckoutAtOptionsForceCopyFieldInfo), '("bareuseronlyDirs", RepoCheckoutAtOptionsBareuseronlyDirsFieldInfo), '("forceCopyZerosized", RepoCheckoutAtOptionsForceCopyZerosizedFieldInfo), '("subpath", RepoCheckoutAtOptionsSubpathFieldInfo), '("devinoToCsumCache", RepoCheckoutAtOptionsDevinoToCsumCacheFieldInfo), '("filter", RepoCheckoutAtOptionsFilterFieldInfo), '("filterUserData", RepoCheckoutAtOptionsFilterUserDataFieldInfo), '("sepolicy", RepoCheckoutAtOptionsSepolicyFieldInfo), '("sepolicyPrefix", RepoCheckoutAtOptionsSepolicyPrefixFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method RepoCheckoutAtOptions::set_devino +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "opts", argType = TInterface (Name {namespace = "OSTree", name = "RepoCheckoutAtOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checkout options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache", argType = TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Devino cache", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_checkout_at_options_set_devino" ostree_repo_checkout_at_options_set_devino :: + Ptr RepoCheckoutAtOptions -> -- opts : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutAtOptions"}) + Ptr OSTree.RepoDevInoCache.RepoDevInoCache -> -- cache : TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}) + IO () + +{- | +This function simply assigns /@cache@/ to the @devino_to_csum_cache@ member of +/@opts@/; it\'s only useful for introspection. + +Note that cache does *not* have its refcount incremented - the lifetime of +/@cache@/ must be equal to or greater than that of /@opts@/. +-} +repoCheckoutAtOptionsSetDevino :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCheckoutAtOptions + {- ^ /@opts@/: Checkout options -} + -> Maybe (OSTree.RepoDevInoCache.RepoDevInoCache) + {- ^ /@cache@/: Devino cache -} + -> m () +repoCheckoutAtOptionsSetDevino opts cache = liftIO $ do + opts' <- unsafeManagedPtrGetPtr opts + maybeCache <- case cache of + Nothing -> return nullPtr + Just jCache -> do + jCache' <- unsafeManagedPtrGetPtr jCache + return jCache' + ostree_repo_checkout_at_options_set_devino opts' maybeCache + touchManagedPtr opts + whenJust cache touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsSetDevinoMethodInfo +instance (signature ~ (Maybe (OSTree.RepoDevInoCache.RepoDevInoCache) -> m ()), MonadIO m) => O.MethodInfo RepoCheckoutAtOptionsSetDevinoMethodInfo RepoCheckoutAtOptions signature where + overloadedMethod _ = repoCheckoutAtOptionsSetDevino + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoCheckoutAtOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoCheckoutAtOptionsMethod "setDevino" o = RepoCheckoutAtOptionsSetDevinoMethodInfo + ResolveRepoCheckoutAtOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoCheckoutAtOptionsMethod t RepoCheckoutAtOptions, O.MethodInfo info RepoCheckoutAtOptions p) => OL.IsLabel t (RepoCheckoutAtOptions -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoCheckoutAtOptions.hs-boot b/GI/OSTree/Structs/RepoCheckoutAtOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCheckoutAtOptions.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoCheckoutAtOptions 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoCheckoutAtOptions = RepoCheckoutAtOptions (ManagedPtr RepoCheckoutAtOptions) +instance WrappedPtr RepoCheckoutAtOptions where +#if ENABLE_OVERLOADING +data RepoCheckoutAtOptionsSetDevinoMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoCommitModifier.hs b/GI/OSTree/Structs/RepoCommitModifier.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCommitModifier.hs @@ -0,0 +1,386 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A structure allowing control over commits. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoCommitModifier + ( + +-- * Exported types + RepoCommitModifier(..) , + noRepoCommitModifier , + + + -- * Methods +-- ** new #method:new# + + repoCommitModifierNew , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RepoCommitModifierRefMethodInfo , +#endif + repoCommitModifierRef , + + +-- ** setDevinoCache #method:setDevinoCache# + +#if ENABLE_OVERLOADING + RepoCommitModifierSetDevinoCacheMethodInfo, +#endif + repoCommitModifierSetDevinoCache , + + +-- ** setSepolicy #method:setSepolicy# + +#if ENABLE_OVERLOADING + RepoCommitModifierSetSepolicyMethodInfo , +#endif + repoCommitModifierSetSepolicy , + + +-- ** setXattrCallback #method:setXattrCallback# + +#if ENABLE_OVERLOADING + RepoCommitModifierSetXattrCallbackMethodInfo, +#endif + repoCommitModifierSetXattrCallback , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RepoCommitModifierUnrefMethodInfo , +#endif + repoCommitModifierUnref , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.OSTree.Callbacks as OSTree.Callbacks +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Objects.SePolicy as OSTree.SePolicy +import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache + +-- | Memory-managed wrapper type. +newtype RepoCommitModifier = RepoCommitModifier (ManagedPtr RepoCommitModifier) +foreign import ccall "ostree_repo_commit_modifier_get_type" c_ostree_repo_commit_modifier_get_type :: + IO GType + +instance BoxedObject RepoCommitModifier where + boxedType _ = c_ostree_repo_commit_modifier_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoCommitModifier`. +noRepoCommitModifier :: Maybe RepoCommitModifier +noRepoCommitModifier = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoCommitModifier +type instance O.AttributeList RepoCommitModifier = RepoCommitModifierAttributeList +type RepoCommitModifierAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RepoCommitModifier::new +-- method type : Constructor +-- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifierFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Control options for filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit_filter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitFilter"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Function that can inspect individual files", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDestroyNotify", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_new" ostree_repo_commit_modifier_new :: + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifierFlags"}) + FunPtr OSTree.Callbacks.C_RepoCommitFilter -> -- commit_filter : TInterface (Name {namespace = "OSTree", name = "RepoCommitFilter"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO (Ptr RepoCommitModifier) + +{- | +/No description available in the introspection data./ +-} +repoCommitModifierNew :: + (B.CallStack.HasCallStack, MonadIO m) => + [OSTree.Flags.RepoCommitModifierFlags] + {- ^ /@flags@/: Control options for filter -} + -> Maybe (OSTree.Callbacks.RepoCommitFilter) + {- ^ /@commitFilter@/: Function that can inspect individual files -} + -> m RepoCommitModifier + {- ^ __Returns:__ A new commit modifier. -} +repoCommitModifierNew flags commitFilter = liftIO $ do + let flags' = gflagsToWord flags + maybeCommitFilter <- case commitFilter of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCommitFilter -> do + jCommitFilter' <- OSTree.Callbacks.mk_RepoCommitFilter (OSTree.Callbacks.wrap_RepoCommitFilter Nothing (OSTree.Callbacks.drop_closures_RepoCommitFilter jCommitFilter)) + return jCommitFilter' + let userData = castFunPtrToPtr maybeCommitFilter + let destroyNotify = safeFreeFunPtrPtr + result <- ostree_repo_commit_modifier_new flags' maybeCommitFilter userData destroyNotify + checkUnexpectedReturnNULL "repoCommitModifierNew" result + result' <- (wrapBoxed RepoCommitModifier) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method RepoCommitModifier::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_ref" ostree_repo_commit_modifier_ref :: + Ptr RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + IO (Ptr RepoCommitModifier) + +{- | +/No description available in the introspection data./ +-} +repoCommitModifierRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitModifier + -> m RepoCommitModifier +repoCommitModifierRef modifier = liftIO $ do + modifier' <- unsafeManagedPtrGetPtr modifier + result <- ostree_repo_commit_modifier_ref modifier' + checkUnexpectedReturnNULL "repoCommitModifierRef" result + result' <- (wrapBoxed RepoCommitModifier) result + touchManagedPtr modifier + return result' + +#if ENABLE_OVERLOADING +data RepoCommitModifierRefMethodInfo +instance (signature ~ (m RepoCommitModifier), MonadIO m) => O.MethodInfo RepoCommitModifierRefMethodInfo RepoCommitModifier signature where + overloadedMethod _ = repoCommitModifierRef + +#endif + +-- method RepoCommitModifier::set_devino_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Modifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache", argType = TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A hash table caching device,inode to checksums", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_set_devino_cache" ostree_repo_commit_modifier_set_devino_cache :: + Ptr RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + Ptr OSTree.RepoDevInoCache.RepoDevInoCache -> -- cache : TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}) + IO () + +{- | +See the documentation for +@ostree_repo_devino_cache_new()@. This function can +then be used for later calls to +@ostree_repo_write_directory_to_mtree()@ to optimize commits. + +Note if your process has multiple writers, you should use separate +@OSTreeRepo@ instances if you want to also use this API. + +This function will add a reference to /@cache@/ without copying - you +should avoid further mutation of the cache. + +/Since: 2017.13/ +-} +repoCommitModifierSetDevinoCache :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitModifier + {- ^ /@modifier@/: Modifier -} + -> OSTree.RepoDevInoCache.RepoDevInoCache + {- ^ /@cache@/: A hash table caching device,inode to checksums -} + -> m () +repoCommitModifierSetDevinoCache modifier cache = liftIO $ do + modifier' <- unsafeManagedPtrGetPtr modifier + cache' <- unsafeManagedPtrGetPtr cache + ostree_repo_commit_modifier_set_devino_cache modifier' cache' + touchManagedPtr modifier + touchManagedPtr cache + return () + +#if ENABLE_OVERLOADING +data RepoCommitModifierSetDevinoCacheMethodInfo +instance (signature ~ (OSTree.RepoDevInoCache.RepoDevInoCache -> m ()), MonadIO m) => O.MethodInfo RepoCommitModifierSetDevinoCacheMethodInfo RepoCommitModifier signature where + overloadedMethod _ = repoCommitModifierSetDevinoCache + +#endif + +-- method RepoCommitModifier::set_sepolicy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepoCommitModifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sepolicy", argType = TInterface (Name {namespace = "OSTree", name = "SePolicy"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Policy to use for labeling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_set_sepolicy" ostree_repo_commit_modifier_set_sepolicy :: + Ptr RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + Ptr OSTree.SePolicy.SePolicy -> -- sepolicy : TInterface (Name {namespace = "OSTree", name = "SePolicy"}) + IO () + +{- | +If /@policy@/ is non-'Nothing', use it to look up labels to use for +\"security.selinux\" extended attributes. + +Note that any policy specified this way operates in addition to any +extended attributes provided via +'GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierSetXattrCallback'. However if both +specify a value for \"security.selinux\", then the one from the +policy wins. +-} +repoCommitModifierSetSepolicy :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.SePolicy.IsSePolicy a) => + RepoCommitModifier + {- ^ /@modifier@/: An 'GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier' -} + -> Maybe (a) + {- ^ /@sepolicy@/: Policy to use for labeling -} + -> m () +repoCommitModifierSetSepolicy modifier sepolicy = liftIO $ do + modifier' <- unsafeManagedPtrGetPtr modifier + maybeSepolicy <- case sepolicy of + Nothing -> return nullPtr + Just jSepolicy -> do + jSepolicy' <- unsafeManagedPtrCastPtr jSepolicy + return jSepolicy' + ostree_repo_commit_modifier_set_sepolicy modifier' maybeSepolicy + touchManagedPtr modifier + whenJust sepolicy touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data RepoCommitModifierSetSepolicyMethodInfo +instance (signature ~ (Maybe (a) -> m ()), MonadIO m, OSTree.SePolicy.IsSePolicy a) => O.MethodInfo RepoCommitModifierSetSepolicyMethodInfo RepoCommitModifier signature where + overloadedMethod _ = repoCommitModifierSetSepolicy + +#endif + +-- method RepoCommitModifier::set_xattr_callback +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #OstreeRepoCommitModifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifierXattrCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Function to be invoked, should return extended attributes for path", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Destroy notification", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Data for @callback:", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_set_xattr_callback" ostree_repo_commit_modifier_set_xattr_callback :: + Ptr RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + FunPtr OSTree.Callbacks.C_RepoCommitModifierXattrCallback -> -- callback : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifierXattrCallback"}) + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +If set, this function should return extended attributes to use for +the given path. This is useful for things like ACLs and SELinux, +where a build system can label the files as it\'s committing to the +repository. +-} +repoCommitModifierSetXattrCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitModifier + {- ^ /@modifier@/: An 'GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier' -} + -> OSTree.Callbacks.RepoCommitModifierXattrCallback + {- ^ /@callback@/: Function to be invoked, should return extended attributes for path -} + -> m () +repoCommitModifierSetXattrCallback modifier callback = liftIO $ do + modifier' <- unsafeManagedPtrGetPtr modifier + callback' <- OSTree.Callbacks.mk_RepoCommitModifierXattrCallback (OSTree.Callbacks.wrap_RepoCommitModifierXattrCallback Nothing (OSTree.Callbacks.drop_closures_RepoCommitModifierXattrCallback callback)) + let userData = castFunPtrToPtr callback' + let destroy = safeFreeFunPtrPtr + ostree_repo_commit_modifier_set_xattr_callback modifier' callback' destroy userData + touchManagedPtr modifier + return () + +#if ENABLE_OVERLOADING +data RepoCommitModifierSetXattrCallbackMethodInfo +instance (signature ~ (OSTree.Callbacks.RepoCommitModifierXattrCallback -> m ()), MonadIO m) => O.MethodInfo RepoCommitModifierSetXattrCallbackMethodInfo RepoCommitModifier signature where + overloadedMethod _ = repoCommitModifierSetXattrCallback + +#endif + +-- method RepoCommitModifier::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "modifier", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_modifier_unref" ostree_repo_commit_modifier_unref :: + Ptr RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"}) + IO () + +{- | +/No description available in the introspection data./ +-} +repoCommitModifierUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitModifier + -> m () +repoCommitModifierUnref modifier = liftIO $ do + modifier' <- unsafeManagedPtrGetPtr modifier + ostree_repo_commit_modifier_unref modifier' + touchManagedPtr modifier + return () + +#if ENABLE_OVERLOADING +data RepoCommitModifierUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RepoCommitModifierUnrefMethodInfo RepoCommitModifier signature where + overloadedMethod _ = repoCommitModifierUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoCommitModifierMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoCommitModifierMethod "ref" o = RepoCommitModifierRefMethodInfo + ResolveRepoCommitModifierMethod "unref" o = RepoCommitModifierUnrefMethodInfo + ResolveRepoCommitModifierMethod "setDevinoCache" o = RepoCommitModifierSetDevinoCacheMethodInfo + ResolveRepoCommitModifierMethod "setSepolicy" o = RepoCommitModifierSetSepolicyMethodInfo + ResolveRepoCommitModifierMethod "setXattrCallback" o = RepoCommitModifierSetXattrCallbackMethodInfo + ResolveRepoCommitModifierMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoCommitModifierMethod t RepoCommitModifier, O.MethodInfo info RepoCommitModifier p) => OL.IsLabel t (RepoCommitModifier -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoCommitModifier.hs-boot b/GI/OSTree/Structs/RepoCommitModifier.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCommitModifier.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoCommitModifier 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoCommitModifier = RepoCommitModifier (ManagedPtr RepoCommitModifier) +instance BoxedObject RepoCommitModifier where +#if ENABLE_OVERLOADING +data RepoCommitModifierRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitModifierSetDevinoCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitModifierSetSepolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitModifierSetXattrCallbackMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitModifierUnrefMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoCommitTraverseIter.hs b/GI/OSTree/Structs/RepoCommitTraverseIter.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCommitTraverseIter.hs @@ -0,0 +1,535 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoCommitTraverseIter + ( + +-- * Exported types + RepoCommitTraverseIter(..) , + newZeroRepoCommitTraverseIter , + noRepoCommitTraverseIter , + + + -- * Methods +-- ** cleanup #method:cleanup# + + repoCommitTraverseIterCleanup , + + +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterClearMethodInfo , +#endif + repoCommitTraverseIterClear , + + +-- ** getDir #method:getDir# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterGetDirMethodInfo , +#endif + repoCommitTraverseIterGetDir , + + +-- ** getFile #method:getFile# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterGetFileMethodInfo , +#endif + repoCommitTraverseIterGetFile , + + +-- ** initCommit #method:initCommit# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterInitCommitMethodInfo, +#endif + repoCommitTraverseIterInitCommit , + + +-- ** initDirtree #method:initDirtree# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterInitDirtreeMethodInfo, +#endif + repoCommitTraverseIterInitDirtree , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + RepoCommitTraverseIterNextMethodInfo , +#endif + repoCommitTraverseIterNext , + + + + + -- * Properties +-- ** initialized #attr:initialized# +{- | /No description available in the introspection data./ +-} + getRepoCommitTraverseIterInitialized , +#if ENABLE_OVERLOADING + repoCommitTraverseIter_initialized , +#endif + setRepoCommitTraverseIterInitialized , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums +import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags +import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo + +-- | Memory-managed wrapper type. +newtype RepoCommitTraverseIter = RepoCommitTraverseIter (ManagedPtr RepoCommitTraverseIter) +instance WrappedPtr RepoCommitTraverseIter where + wrappedPtrCalloc = callocBytes 224 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 224 >=> wrapPtr RepoCommitTraverseIter) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `RepoCommitTraverseIter` struct initialized to zero. +newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter +newZeroRepoCommitTraverseIter = liftIO $ wrappedPtrCalloc >>= wrapPtr RepoCommitTraverseIter + +instance tag ~ 'AttrSet => Constructible RepoCommitTraverseIter tag where + new _ attrs = do + o <- newZeroRepoCommitTraverseIter + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoCommitTraverseIter`. +noRepoCommitTraverseIter :: Maybe RepoCommitTraverseIter +noRepoCommitTraverseIter = Nothing + +{- | +Get the value of the “@initialized@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoCommitTraverseIter #initialized +@ +-} +getRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> m Bool +getRepoCommitTraverseIterInitialized s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@initialized@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoCommitTraverseIter [ #initialized 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> Bool -> m () +setRepoCommitTraverseIterInitialized s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CInt) + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterInitializedFieldInfo +instance AttrInfo RepoCommitTraverseIterInitializedFieldInfo where + type AttrAllowedOps RepoCommitTraverseIterInitializedFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) Bool + type AttrBaseTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) RepoCommitTraverseIter + type AttrGetType RepoCommitTraverseIterInitializedFieldInfo = Bool + type AttrLabel RepoCommitTraverseIterInitializedFieldInfo = "initialized" + type AttrOrigin RepoCommitTraverseIterInitializedFieldInfo = RepoCommitTraverseIter + attrGet _ = getRepoCommitTraverseIterInitialized + attrSet _ = setRepoCommitTraverseIterInitialized + attrConstruct = undefined + attrClear _ = undefined + +repoCommitTraverseIter_initialized :: AttrLabelProxy "initialized" +repoCommitTraverseIter_initialized = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoCommitTraverseIter:dummy" :: Not implemented: "Don't know how to unpack C array of type TCArray False 10 (-1) (TBasicType TPtr)" +-- XXX Skipped attribute for "RepoCommitTraverseIter:dummy_checksum_data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 130 (-1) (TBasicType TInt8)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoCommitTraverseIter +type instance O.AttributeList RepoCommitTraverseIter = RepoCommitTraverseIterAttributeList +type RepoCommitTraverseIterAttributeList = ('[ '("initialized", RepoCommitTraverseIterInitializedFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method RepoCommitTraverseIter::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_clear" ostree_repo_commit_traverse_iter_clear :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + IO () + +{- | +/No description available in the introspection data./ +-} +repoCommitTraverseIterClear :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitTraverseIter + -> m () +repoCommitTraverseIterClear iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + ostree_repo_commit_traverse_iter_clear iter' + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterClearMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RepoCommitTraverseIterClearMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterClear + +#endif + +-- method RepoCommitTraverseIter::get_dir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An iter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of current dir", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_content_checksum", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum of current content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_meta_checksum", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum of current metadata", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_get_dir" ostree_repo_commit_traverse_iter_get_dir :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + Ptr CString -> -- out_name : TBasicType TUTF8 + Ptr CString -> -- out_content_checksum : TBasicType TUTF8 + Ptr CString -> -- out_meta_checksum : TBasicType TUTF8 + IO () + +{- | +Return information on the current directory. This function may +only be called if 'GI.OSTree.Enums.RepoCommitIterResultDir' was returned +from 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'. +-} +repoCommitTraverseIterGetDir :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitTraverseIter + {- ^ /@iter@/: An iter -} + -> m ((T.Text, T.Text, T.Text)) +repoCommitTraverseIterGetDir iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + outName <- allocMem :: IO (Ptr CString) + outContentChecksum <- allocMem :: IO (Ptr CString) + outMetaChecksum <- allocMem :: IO (Ptr CString) + ostree_repo_commit_traverse_iter_get_dir iter' outName outContentChecksum outMetaChecksum + outName' <- peek outName + outName'' <- cstringToText outName' + outContentChecksum' <- peek outContentChecksum + outContentChecksum'' <- cstringToText outContentChecksum' + outMetaChecksum' <- peek outMetaChecksum + outMetaChecksum'' <- cstringToText outMetaChecksum' + touchManagedPtr iter + freeMem outName + freeMem outContentChecksum + freeMem outMetaChecksum + return (outName'', outContentChecksum'', outMetaChecksum'') + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterGetDirMethodInfo +instance (signature ~ (m ((T.Text, T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetDirMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterGetDir + +#endif + +-- method RepoCommitTraverseIter::get_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An iter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of current file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_checksum", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum of current file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_get_file" ostree_repo_commit_traverse_iter_get_file :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + Ptr CString -> -- out_name : TBasicType TUTF8 + Ptr CString -> -- out_checksum : TBasicType TUTF8 + IO () + +{- | +Return information on the current file. This function may only be +called if 'GI.OSTree.Enums.RepoCommitIterResultFile' was returned from +'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'. +-} +repoCommitTraverseIterGetFile :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoCommitTraverseIter + {- ^ /@iter@/: An iter -} + -> m ((T.Text, T.Text)) +repoCommitTraverseIterGetFile iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + outName <- allocMem :: IO (Ptr CString) + outChecksum <- allocMem :: IO (Ptr CString) + ostree_repo_commit_traverse_iter_get_file iter' outName outChecksum + outName' <- peek outName + outName'' <- cstringToText outName' + outChecksum' <- peek outChecksum + outChecksum'' <- cstringToText outChecksum' + touchManagedPtr iter + freeMem outName + freeMem outChecksum + return (outName'', outChecksum'') + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterGetFileMethodInfo +instance (signature ~ (m ((T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetFileMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterGetFile + +#endif + +-- method RepoCommitTraverseIter::init_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An iter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Variant of type %OSTREE_OBJECT_TYPE_COMMIT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_init_commit" ostree_repo_commit_traverse_iter_init_commit :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + Ptr OSTree.Repo.Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr GVariant -> -- commit : TVariant + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Initialize (in place) an iterator over the root of a commit object. +-} +repoCommitTraverseIterInitCommit :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + RepoCommitTraverseIter + {- ^ /@iter@/: An iter -} + -> a + {- ^ /@repo@/: A repo -} + -> GVariant + {- ^ /@commit@/: Variant of type 'GI.OSTree.Enums.ObjectTypeCommit' -} + -> [OSTree.Flags.RepoCommitTraverseFlags] + {- ^ /@flags@/: Flags -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCommitTraverseIterInitCommit iter repo commit flags = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + repo' <- unsafeManagedPtrCastPtr repo + commit' <- unsafeManagedPtrGetPtr commit + let flags' = gflagsToWord flags + onException (do + _ <- propagateGError $ ostree_repo_commit_traverse_iter_init_commit iter' repo' commit' flags' + touchManagedPtr iter + touchManagedPtr repo + touchManagedPtr commit + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterInitCommitMethodInfo +instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitCommitMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterInitCommit + +#endif + +-- method RepoCommitTraverseIter::init_dirtree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An iter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dirtree", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Variant of type %OSTREE_OBJECT_TYPE_DIR_TREE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_init_dirtree" ostree_repo_commit_traverse_iter_init_dirtree :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + Ptr OSTree.Repo.Repo -> -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"}) + Ptr GVariant -> -- dirtree : TVariant + CUInt -> -- flags : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Initialize (in place) an iterator over a directory tree. +-} +repoCommitTraverseIterInitDirtree :: + (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) => + RepoCommitTraverseIter + {- ^ /@iter@/: An iter -} + -> a + {- ^ /@repo@/: A repo -} + -> GVariant + {- ^ /@dirtree@/: Variant of type 'GI.OSTree.Enums.ObjectTypeDirTree' -} + -> [OSTree.Flags.RepoCommitTraverseFlags] + {- ^ /@flags@/: Flags -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCommitTraverseIterInitDirtree iter repo dirtree flags = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + repo' <- unsafeManagedPtrCastPtr repo + dirtree' <- unsafeManagedPtrGetPtr dirtree + let flags' = gflagsToWord flags + onException (do + _ <- propagateGError $ ostree_repo_commit_traverse_iter_init_dirtree iter' repo' dirtree' flags' + touchManagedPtr iter + touchManagedPtr repo + touchManagedPtr dirtree + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterInitDirtreeMethodInfo +instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitDirtreeMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterInitDirtree + +#endif + +-- method RepoCommitTraverseIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An iter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitIterResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_next" ostree_repo_commit_traverse_iter_next :: + Ptr RepoCommitTraverseIter -> -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO CUInt + +{- | +Step the interator to the next item. Files will be returned first, +then subdirectories. Call this in a loop; upon encountering +'GI.OSTree.Enums.RepoCommitIterResultEnd', there will be no more files or +directories. If 'GI.OSTree.Enums.RepoCommitIterResultDir' is returned, +then call 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetDir' to retrieve +data for that directory. Similarly, if +'GI.OSTree.Enums.RepoCommitIterResultFile' is returned, call +'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetFile'. + +If 'GI.OSTree.Enums.RepoCommitIterResultError' is returned, it is a +program error to call any further API on /@iter@/ except for +'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterClear'. +-} +repoCommitTraverseIterNext :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) => + RepoCommitTraverseIter + {- ^ /@iter@/: An iter -} + -> Maybe (a) + {- ^ /@cancellable@/: Cancellable -} + -> m OSTree.Enums.RepoCommitIterResult + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repoCommitTraverseIterNext iter cancellable = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ ostree_repo_commit_traverse_iter_next iter' maybeCancellable + let result' = (toEnum . fromIntegral) result + touchManagedPtr iter + whenJust cancellable touchManagedPtr + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterNextMethodInfo +instance (signature ~ (Maybe (a) -> m OSTree.Enums.RepoCommitIterResult), MonadIO m, Gio.Cancellable.IsCancellable a) => O.MethodInfo RepoCommitTraverseIterNextMethodInfo RepoCommitTraverseIter signature where + overloadedMethod _ = repoCommitTraverseIterNext + +#endif + +-- method RepoCommitTraverseIter::cleanup +-- method type : MemberFunction +-- Args : [Arg {argCName = "p", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_commit_traverse_iter_cleanup" ostree_repo_commit_traverse_iter_cleanup :: + Ptr () -> -- p : TBasicType TPtr + IO () + +{- | +/No description available in the introspection data./ +-} +repoCommitTraverseIterCleanup :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -> m () +repoCommitTraverseIterCleanup p = liftIO $ do + ostree_repo_commit_traverse_iter_cleanup p + return () + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoCommitTraverseIterMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoCommitTraverseIterMethod "clear" o = RepoCommitTraverseIterClearMethodInfo + ResolveRepoCommitTraverseIterMethod "initCommit" o = RepoCommitTraverseIterInitCommitMethodInfo + ResolveRepoCommitTraverseIterMethod "initDirtree" o = RepoCommitTraverseIterInitDirtreeMethodInfo + ResolveRepoCommitTraverseIterMethod "next" o = RepoCommitTraverseIterNextMethodInfo + ResolveRepoCommitTraverseIterMethod "getDir" o = RepoCommitTraverseIterGetDirMethodInfo + ResolveRepoCommitTraverseIterMethod "getFile" o = RepoCommitTraverseIterGetFileMethodInfo + ResolveRepoCommitTraverseIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoCommitTraverseIterMethod t RepoCommitTraverseIter, O.MethodInfo info RepoCommitTraverseIter p) => OL.IsLabel t (RepoCommitTraverseIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoCommitTraverseIter.hs-boot b/GI/OSTree/Structs/RepoCommitTraverseIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoCommitTraverseIter.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoCommitTraverseIter 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoCommitTraverseIter = RepoCommitTraverseIter (ManagedPtr RepoCommitTraverseIter) +instance WrappedPtr RepoCommitTraverseIter where +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterGetDirMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterGetFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterInitCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterInitDirtreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoCommitTraverseIterNextMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoDevInoCache.hs b/GI/OSTree/Structs/RepoDevInoCache.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoDevInoCache.hs @@ -0,0 +1,202 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoDevInoCache + ( + +-- * Exported types + RepoDevInoCache(..) , + noRepoDevInoCache , + + + -- * Methods +-- ** new #method:new# + + repoDevInoCacheNew , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RepoDevInoCacheRefMethodInfo , +#endif + repoDevInoCacheRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RepoDevInoCacheUnrefMethodInfo , +#endif + repoDevInoCacheUnref , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype RepoDevInoCache = RepoDevInoCache (ManagedPtr RepoDevInoCache) +foreign import ccall "ostree_repo_devino_cache_get_type" c_ostree_repo_devino_cache_get_type :: + IO GType + +instance BoxedObject RepoDevInoCache where + boxedType _ = c_ostree_repo_devino_cache_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoDevInoCache`. +noRepoDevInoCache :: Maybe RepoDevInoCache +noRepoDevInoCache = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoDevInoCache +type instance O.AttributeList RepoDevInoCache = RepoDevInoCacheAttributeList +type RepoDevInoCacheAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RepoDevInoCache::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_devino_cache_new" ostree_repo_devino_cache_new :: + IO (Ptr RepoDevInoCache) + +{- | +OSTree has support for pairing @/ostree_repo_checkout_tree_at()/@ using +hardlinks in combination with a later +'GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree' using a (normally modified) +directory. In order for OSTree to optimally detect just the new +files, use this function and fill in the @devino_to_csum_cache@ +member of @OstreeRepoCheckoutAtOptions@, then call +@/ostree_repo_commit_set_devino_cache()/@. +-} +repoDevInoCacheNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m RepoDevInoCache + {- ^ __Returns:__ Newly allocated cache -} +repoDevInoCacheNew = liftIO $ do + result <- ostree_repo_devino_cache_new + checkUnexpectedReturnNULL "repoDevInoCacheNew" result + result' <- (wrapBoxed RepoDevInoCache) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method RepoDevInoCache::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cache", argType = TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_devino_cache_ref" ostree_repo_devino_cache_ref :: + Ptr RepoDevInoCache -> -- cache : TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}) + IO (Ptr RepoDevInoCache) + +{- | +/No description available in the introspection data./ +-} +repoDevInoCacheRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoDevInoCache + -> m RepoDevInoCache +repoDevInoCacheRef cache = liftIO $ do + cache' <- unsafeManagedPtrGetPtr cache + result <- ostree_repo_devino_cache_ref cache' + checkUnexpectedReturnNULL "repoDevInoCacheRef" result + result' <- (wrapBoxed RepoDevInoCache) result + touchManagedPtr cache + return result' + +#if ENABLE_OVERLOADING +data RepoDevInoCacheRefMethodInfo +instance (signature ~ (m RepoDevInoCache), MonadIO m) => O.MethodInfo RepoDevInoCacheRefMethodInfo RepoDevInoCache signature where + overloadedMethod _ = repoDevInoCacheRef + +#endif + +-- method RepoDevInoCache::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cache", argType = TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_devino_cache_unref" ostree_repo_devino_cache_unref :: + Ptr RepoDevInoCache -> -- cache : TInterface (Name {namespace = "OSTree", name = "RepoDevInoCache"}) + IO () + +{- | +/No description available in the introspection data./ +-} +repoDevInoCacheUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoDevInoCache + -> m () +repoDevInoCacheUnref cache = liftIO $ do + cache' <- unsafeManagedPtrGetPtr cache + ostree_repo_devino_cache_unref cache' + touchManagedPtr cache + return () + +#if ENABLE_OVERLOADING +data RepoDevInoCacheUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RepoDevInoCacheUnrefMethodInfo RepoDevInoCache signature where + overloadedMethod _ = repoDevInoCacheUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoDevInoCacheMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoDevInoCacheMethod "ref" o = RepoDevInoCacheRefMethodInfo + ResolveRepoDevInoCacheMethod "unref" o = RepoDevInoCacheUnrefMethodInfo + ResolveRepoDevInoCacheMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoDevInoCacheMethod t RepoDevInoCache, O.MethodInfo info RepoDevInoCache p) => OL.IsLabel t (RepoDevInoCache -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoDevInoCache.hs-boot b/GI/OSTree/Structs/RepoDevInoCache.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoDevInoCache.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoDevInoCache 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoDevInoCache = RepoDevInoCache (ManagedPtr RepoDevInoCache) +instance BoxedObject RepoDevInoCache where +#if ENABLE_OVERLOADING +data RepoDevInoCacheRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoDevInoCacheUnrefMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoFileEnumerator.hs b/GI/OSTree/Structs/RepoFileEnumerator.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoFileEnumerator.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoFileEnumerator + ( + +-- * Exported types + RepoFileEnumerator(..) , + noRepoFileEnumerator , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype RepoFileEnumerator = RepoFileEnumerator (ManagedPtr RepoFileEnumerator) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr RepoFileEnumerator where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFileEnumerator`. +noRepoFileEnumerator :: Maybe RepoFileEnumerator +noRepoFileEnumerator = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFileEnumerator +type instance O.AttributeList RepoFileEnumerator = RepoFileEnumeratorAttributeList +type RepoFileEnumeratorAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoFileEnumeratorMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFileEnumeratorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFileEnumeratorMethod t RepoFileEnumerator, O.MethodInfo info RepoFileEnumerator p) => OL.IsLabel t (RepoFileEnumerator -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoFileEnumerator.hs-boot b/GI/OSTree/Structs/RepoFileEnumerator.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoFileEnumerator.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoFileEnumerator 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFileEnumerator = RepoFileEnumerator (ManagedPtr RepoFileEnumerator) +instance WrappedPtr RepoFileEnumerator where diff --git a/GI/OSTree/Structs/RepoFinderResult.hs b/GI/OSTree/Structs/RepoFinderResult.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoFinderResult.hs @@ -0,0 +1,565 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' gives a single result from an +'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' or 'GI.OSTree.Functions.repoFinderResolveAllAsync' +operation. This represents a single remote which provides none, some or all +of the refs being resolved. The structure includes various bits of metadata +which allow 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' (for example) to prioritise +how to pull the refs. + +The /@priority@/ is used as one input of many to ordering functions like +'GI.OSTree.Structs.RepoFinderResult.repoFinderResultCompare'. + +/@refToChecksum@/ indicates which refs (out of the ones queried for as inputs +to 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync') are provided by this remote. The refs +are present as keys (of type 'GI.OSTree.Structs.CollectionRef.CollectionRef'), and the corresponding values +are the checksums of the commits the remote currently has for those refs. (These +might not be the latest commits available out of all results.) A +checksum may be 'Nothing' if the remote does not advertise the corresponding ref. +After 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' has been called, the commit metadata +should be available locally, so the details for each checksum can be looked +up using 'GI.OSTree.Objects.Repo.repoLoadCommit'. + +/@refToTimestamp@/ provides timestamps for the set of refs in +/@refToChecksum@/. The refs are keys (of type 'GI.OSTree.Structs.CollectionRef.CollectionRef') and the +values are guint64 pointers with the timestamp associated with the checksum +provided in /@refToChecksum@/. /@refToTimestamp@/ can be 'Nothing', and when it\'s +not, the timestamps are zero when any of the following conditions are met: +(1) the override-commit-ids option was used on +ostree_repo_find_remotes_async (2) there was an error in trying to get the +commit metadata (3) the checksum for this ref is 'Nothing' in /@refToChecksum@/. + +/Since: 2018.6/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoFinderResult + ( + +-- * Exported types + RepoFinderResult(..) , + newZeroRepoFinderResult , + noRepoFinderResult , + + + -- * Methods +-- ** compare #method:compare# + +#if ENABLE_OVERLOADING + RepoFinderResultCompareMethodInfo , +#endif + repoFinderResultCompare , + + +-- ** dup #method:dup# + +#if ENABLE_OVERLOADING + RepoFinderResultDupMethodInfo , +#endif + repoFinderResultDup , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + RepoFinderResultFreeMethodInfo , +#endif + repoFinderResultFree , + + +-- ** freev #method:freev# + + repoFinderResultFreev , + + + + + -- * Properties +-- ** finder #attr:finder# +{- | the 'GI.OSTree.Interfaces.RepoFinder.RepoFinder' instance which produced this result +-} + clearRepoFinderResultFinder , + getRepoFinderResultFinder , +#if ENABLE_OVERLOADING + repoFinderResult_finder , +#endif + setRepoFinderResultFinder , + + +-- ** priority #attr:priority# +{- | static priority of the result, where higher numbers indicate lower + priority +-} + getRepoFinderResultPriority , +#if ENABLE_OVERLOADING + repoFinderResult_priority , +#endif + setRepoFinderResultPriority , + + +-- ** remote #attr:remote# +{- | 'GI.OSTree.Structs.Remote.Remote' which contains the transport details for the result, + such as its URI and GPG key +-} + clearRepoFinderResultRemote , + getRepoFinderResultRemote , +#if ENABLE_OVERLOADING + repoFinderResult_remote , +#endif + setRepoFinderResultRemote , + + +-- ** summaryLastModified #attr:summaryLastModified# +{- | Unix timestamp (seconds since the epoch, UTC) when + the summary file on the remote was last modified, or @0@ if unknown +-} + getRepoFinderResultSummaryLastModified , +#if ENABLE_OVERLOADING + repoFinderResult_summaryLastModified , +#endif + setRepoFinderResultSummaryLastModified , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder +import {-# SOURCE #-} qualified GI.OSTree.Structs.Remote as OSTree.Remote + +-- | Memory-managed wrapper type. +newtype RepoFinderResult = RepoFinderResult (ManagedPtr RepoFinderResult) +foreign import ccall "ostree_repo_finder_result_get_type" c_ostree_repo_finder_result_get_type :: + IO GType + +instance BoxedObject RepoFinderResult where + boxedType _ = c_ostree_repo_finder_result_get_type + +-- | Construct a `RepoFinderResult` struct initialized to zero. +newZeroRepoFinderResult :: MonadIO m => m RepoFinderResult +newZeroRepoFinderResult = liftIO $ callocBoxedBytes 72 >>= wrapBoxed RepoFinderResult + +instance tag ~ 'AttrSet => Constructible RepoFinderResult tag where + new _ attrs = do + o <- newZeroRepoFinderResult + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoFinderResult`. +noRepoFinderResult :: Maybe RepoFinderResult +noRepoFinderResult = Nothing + +{- | +Get the value of the “@remote@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoFinderResult #remote +@ +-} +getRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> m (Maybe OSTree.Remote.Remote) +getRepoFinderResultRemote s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr OSTree.Remote.Remote) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed OSTree.Remote.Remote) val' + return val'' + return result + +{- | +Set the value of the “@remote@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoFinderResult [ #remote 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> Ptr OSTree.Remote.Remote -> m () +setRepoFinderResultRemote s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr OSTree.Remote.Remote) + +{- | +Set the value of the “@remote@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #remote +@ +-} +clearRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> m () +clearRepoFinderResultRemote s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr OSTree.Remote.Remote) + +#if ENABLE_OVERLOADING +data RepoFinderResultRemoteFieldInfo +instance AttrInfo RepoFinderResultRemoteFieldInfo where + type AttrAllowedOps RepoFinderResultRemoteFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoFinderResultRemoteFieldInfo = (~) (Ptr OSTree.Remote.Remote) + type AttrBaseTypeConstraint RepoFinderResultRemoteFieldInfo = (~) RepoFinderResult + type AttrGetType RepoFinderResultRemoteFieldInfo = Maybe OSTree.Remote.Remote + type AttrLabel RepoFinderResultRemoteFieldInfo = "remote" + type AttrOrigin RepoFinderResultRemoteFieldInfo = RepoFinderResult + attrGet _ = getRepoFinderResultRemote + attrSet _ = setRepoFinderResultRemote + attrConstruct = undefined + attrClear _ = clearRepoFinderResultRemote + +repoFinderResult_remote :: AttrLabelProxy "remote" +repoFinderResult_remote = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@finder@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoFinderResult #finder +@ +-} +getRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> m (Maybe OSTree.RepoFinder.RepoFinder) +getRepoFinderResultFinder s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr OSTree.RepoFinder.RepoFinder) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject OSTree.RepoFinder.RepoFinder) val' + return val'' + return result + +{- | +Set the value of the “@finder@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoFinderResult [ #finder 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> Ptr OSTree.RepoFinder.RepoFinder -> m () +setRepoFinderResultFinder s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr OSTree.RepoFinder.RepoFinder) + +{- | +Set the value of the “@finder@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #finder +@ +-} +clearRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> m () +clearRepoFinderResultFinder s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr OSTree.RepoFinder.RepoFinder) + +#if ENABLE_OVERLOADING +data RepoFinderResultFinderFieldInfo +instance AttrInfo RepoFinderResultFinderFieldInfo where + type AttrAllowedOps RepoFinderResultFinderFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoFinderResultFinderFieldInfo = (~) (Ptr OSTree.RepoFinder.RepoFinder) + type AttrBaseTypeConstraint RepoFinderResultFinderFieldInfo = (~) RepoFinderResult + type AttrGetType RepoFinderResultFinderFieldInfo = Maybe OSTree.RepoFinder.RepoFinder + type AttrLabel RepoFinderResultFinderFieldInfo = "finder" + type AttrOrigin RepoFinderResultFinderFieldInfo = RepoFinderResult + attrGet _ = getRepoFinderResultFinder + attrSet _ = setRepoFinderResultFinder + attrConstruct = undefined + attrClear _ = clearRepoFinderResultFinder + +repoFinderResult_finder :: AttrLabelProxy "finder" +repoFinderResult_finder = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@priority@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoFinderResult #priority +@ +-} +getRepoFinderResultPriority :: MonadIO m => RepoFinderResult -> m Int32 +getRepoFinderResultPriority s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Int32 + return val + +{- | +Set the value of the “@priority@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoFinderResult [ #priority 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoFinderResultPriority :: MonadIO m => RepoFinderResult -> Int32 -> m () +setRepoFinderResultPriority s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Int32) + +#if ENABLE_OVERLOADING +data RepoFinderResultPriorityFieldInfo +instance AttrInfo RepoFinderResultPriorityFieldInfo where + type AttrAllowedOps RepoFinderResultPriorityFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoFinderResultPriorityFieldInfo = (~) Int32 + type AttrBaseTypeConstraint RepoFinderResultPriorityFieldInfo = (~) RepoFinderResult + type AttrGetType RepoFinderResultPriorityFieldInfo = Int32 + type AttrLabel RepoFinderResultPriorityFieldInfo = "priority" + type AttrOrigin RepoFinderResultPriorityFieldInfo = RepoFinderResult + attrGet _ = getRepoFinderResultPriority + attrSet _ = setRepoFinderResultPriority + attrConstruct = undefined + attrClear _ = undefined + +repoFinderResult_priority :: AttrLabelProxy "priority" +repoFinderResult_priority = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoFinderResult:ref_to_checksum" :: Not implemented: "GHashTable element of type TInterface (Name {namespace = \"OSTree\", name = \"CollectionRef\"}) unsupported." +{- | +Get the value of the “@summary_last_modified@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoFinderResult #summaryLastModified +@ +-} +getRepoFinderResultSummaryLastModified :: MonadIO m => RepoFinderResult -> m Word64 +getRepoFinderResultSummaryLastModified s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word64 + return val + +{- | +Set the value of the “@summary_last_modified@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoFinderResult [ #summaryLastModified 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoFinderResultSummaryLastModified :: MonadIO m => RepoFinderResult -> Word64 -> m () +setRepoFinderResultSummaryLastModified s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word64) + +#if ENABLE_OVERLOADING +data RepoFinderResultSummaryLastModifiedFieldInfo +instance AttrInfo RepoFinderResultSummaryLastModifiedFieldInfo where + type AttrAllowedOps RepoFinderResultSummaryLastModifiedFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoFinderResultSummaryLastModifiedFieldInfo = (~) Word64 + type AttrBaseTypeConstraint RepoFinderResultSummaryLastModifiedFieldInfo = (~) RepoFinderResult + type AttrGetType RepoFinderResultSummaryLastModifiedFieldInfo = Word64 + type AttrLabel RepoFinderResultSummaryLastModifiedFieldInfo = "summary_last_modified" + type AttrOrigin RepoFinderResultSummaryLastModifiedFieldInfo = RepoFinderResult + attrGet _ = getRepoFinderResultSummaryLastModified + attrSet _ = setRepoFinderResultSummaryLastModified + attrConstruct = undefined + attrClear _ = undefined + +repoFinderResult_summaryLastModified :: AttrLabelProxy "summaryLastModified" +repoFinderResult_summaryLastModified = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoFinderResult:ref_to_timestamp" :: Not implemented: "GHashTable element of type TInterface (Name {namespace = \"OSTree\", name = \"CollectionRef\"}) unsupported." + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoFinderResult +type instance O.AttributeList RepoFinderResult = RepoFinderResultAttributeList +type RepoFinderResultAttributeList = ('[ '("remote", RepoFinderResultRemoteFieldInfo), '("finder", RepoFinderResultFinderFieldInfo), '("priority", RepoFinderResultPriorityFieldInfo), '("summaryLastModified", RepoFinderResultSummaryLastModifiedFieldInfo)] :: [(Symbol, *)]) +#endif + +-- XXX Could not generate method RepoFinderResult::new +-- Error was : Not implemented: "GHashTable key of type TInterface (Name {namespace = \"OSTree\", name = \"CollectionRef\"}) unsupported." +-- method RepoFinderResult::compare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_result_compare" ostree_repo_finder_result_compare :: + Ptr RepoFinderResult -> -- a : TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}) + Ptr RepoFinderResult -> -- b : TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}) + IO Int32 + +{- | +Compare two 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' instances to work out which one is better +to pull from, and hence needs to be ordered before the other. + +/Since: 2018.6/ +-} +repoFinderResultCompare :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoFinderResult + {- ^ /@a@/: an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' -} + -> RepoFinderResult + {- ^ /@b@/: an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' -} + -> m Int32 + {- ^ __Returns:__ \<0 if /@a@/ is ordered before /@b@/, 0 if they are ordered equally, + >0 if /@b@/ is ordered before /@a@/ -} +repoFinderResultCompare a b = liftIO $ do + a' <- unsafeManagedPtrGetPtr a + b' <- unsafeManagedPtrGetPtr b + result <- ostree_repo_finder_result_compare a' b' + touchManagedPtr a + touchManagedPtr b + return result + +#if ENABLE_OVERLOADING +data RepoFinderResultCompareMethodInfo +instance (signature ~ (RepoFinderResult -> m Int32), MonadIO m) => O.MethodInfo RepoFinderResultCompareMethodInfo RepoFinderResult signature where + overloadedMethod _ = repoFinderResultCompare + +#endif + +-- method RepoFinderResult::dup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderResult to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_result_dup" ostree_repo_finder_result_dup :: + Ptr RepoFinderResult -> -- result : TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}) + IO (Ptr RepoFinderResult) + +{- | +Copy an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult'. + +/Since: 2018.6/ +-} +repoFinderResultDup :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoFinderResult + {- ^ /@result@/: an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' to copy -} + -> m RepoFinderResult + {- ^ __Returns:__ a newly allocated copy of /@result@/ -} +repoFinderResultDup result_ = liftIO $ do + result_' <- unsafeManagedPtrGetPtr result_ + result <- ostree_repo_finder_result_dup result_' + checkUnexpectedReturnNULL "repoFinderResultDup" result + result' <- (wrapBoxed RepoFinderResult) result + touchManagedPtr result_ + return result' + +#if ENABLE_OVERLOADING +data RepoFinderResultDupMethodInfo +instance (signature ~ (m RepoFinderResult), MonadIO m) => O.MethodInfo RepoFinderResultDupMethodInfo RepoFinderResult signature where + overloadedMethod _ = repoFinderResultDup + +#endif + +-- method RepoFinderResult::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_result_free" ostree_repo_finder_result_free :: + Ptr RepoFinderResult -> -- result : TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}) + IO () + +{- | +Free the given /@result@/. + +/Since: 2018.6/ +-} +repoFinderResultFree :: + (B.CallStack.HasCallStack, MonadIO m) => + RepoFinderResult + {- ^ /@result@/: an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' -} + -> m () +repoFinderResultFree result_ = liftIO $ do + result_' <- B.ManagedPtr.disownBoxed result_ + ostree_repo_finder_result_free result_' + touchManagedPtr result_ + return () + +#if ENABLE_OVERLOADING +data RepoFinderResultFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RepoFinderResultFreeMethodInfo RepoFinderResult signature where + overloadedMethod _ = repoFinderResultFree + +#endif + +-- method RepoFinderResult::freev +-- method type : MemberFunction +-- Args : [Arg {argCName = "results", argType = TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #OstreeRepoFinderResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ostree_repo_finder_result_freev" ostree_repo_finder_result_freev :: + Ptr (Ptr RepoFinderResult) -> -- results : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"})) + IO () + +{- | +Free the given /@results@/ array, freeing each element and the container. + +/Since: 2018.6/ +-} +repoFinderResultFreev :: + (B.CallStack.HasCallStack, MonadIO m) => + [RepoFinderResult] + {- ^ /@results@/: an 'GI.OSTree.Structs.RepoFinderResult.RepoFinderResult' -} + -> m () +repoFinderResultFreev results = liftIO $ do + results' <- mapM B.ManagedPtr.disownBoxed results + results'' <- packZeroTerminatedPtrArray results' + ostree_repo_finder_result_freev results'' + mapM_ touchManagedPtr results + return () + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoFinderResultMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoFinderResultMethod "compare" o = RepoFinderResultCompareMethodInfo + ResolveRepoFinderResultMethod "dup" o = RepoFinderResultDupMethodInfo + ResolveRepoFinderResultMethod "free" o = RepoFinderResultFreeMethodInfo + ResolveRepoFinderResultMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoFinderResultMethod t RepoFinderResult, O.MethodInfo info RepoFinderResult p) => OL.IsLabel t (RepoFinderResult -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoFinderResult.hs-boot b/GI/OSTree/Structs/RepoFinderResult.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoFinderResult.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoFinderResult 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoFinderResult = RepoFinderResult (ManagedPtr RepoFinderResult) +instance BoxedObject RepoFinderResult where +#if ENABLE_OVERLOADING +data RepoFinderResultCompareMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFinderResultDupMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepoFinderResultFreeMethodInfo +#endif diff --git a/GI/OSTree/Structs/RepoPruneOptions.hs b/GI/OSTree/Structs/RepoPruneOptions.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoPruneOptions.hs @@ -0,0 +1,226 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoPruneOptions + ( + +-- * Exported types + RepoPruneOptions(..) , + newZeroRepoPruneOptions , + noRepoPruneOptions , + + + -- * Properties +-- ** flags #attr:flags# +{- | /No description available in the introspection data./ +-} + getRepoPruneOptionsFlags , +#if ENABLE_OVERLOADING + repoPruneOptions_flags , +#endif + setRepoPruneOptionsFlags , + + +-- ** reachable #attr:reachable# +{- | /No description available in the introspection data./ +-} + clearRepoPruneOptionsReachable , + getRepoPruneOptionsReachable , +#if ENABLE_OVERLOADING + repoPruneOptions_reachable , +#endif + setRepoPruneOptionsReachable , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums + +-- | Memory-managed wrapper type. +newtype RepoPruneOptions = RepoPruneOptions (ManagedPtr RepoPruneOptions) +instance WrappedPtr RepoPruneOptions where + wrappedPtrCalloc = callocBytes 120 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 120 >=> wrapPtr RepoPruneOptions) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `RepoPruneOptions` struct initialized to zero. +newZeroRepoPruneOptions :: MonadIO m => m RepoPruneOptions +newZeroRepoPruneOptions = liftIO $ wrappedPtrCalloc >>= wrapPtr RepoPruneOptions + +instance tag ~ 'AttrSet => Constructible RepoPruneOptions tag where + new _ attrs = do + o <- newZeroRepoPruneOptions + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoPruneOptions`. +noRepoPruneOptions :: Maybe RepoPruneOptions +noRepoPruneOptions = Nothing + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoPruneOptions #flags +@ +-} +getRepoPruneOptionsFlags :: MonadIO m => RepoPruneOptions -> m OSTree.Enums.RepoPruneFlags +getRepoPruneOptionsFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoPruneOptions [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoPruneOptionsFlags :: MonadIO m => RepoPruneOptions -> OSTree.Enums.RepoPruneFlags -> m () +setRepoPruneOptionsFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data RepoPruneOptionsFlagsFieldInfo +instance AttrInfo RepoPruneOptionsFlagsFieldInfo where + type AttrAllowedOps RepoPruneOptionsFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoPruneOptionsFlagsFieldInfo = (~) OSTree.Enums.RepoPruneFlags + type AttrBaseTypeConstraint RepoPruneOptionsFlagsFieldInfo = (~) RepoPruneOptions + type AttrGetType RepoPruneOptionsFlagsFieldInfo = OSTree.Enums.RepoPruneFlags + type AttrLabel RepoPruneOptionsFlagsFieldInfo = "flags" + type AttrOrigin RepoPruneOptionsFlagsFieldInfo = RepoPruneOptions + attrGet _ = getRepoPruneOptionsFlags + attrSet _ = setRepoPruneOptionsFlags + attrConstruct = undefined + attrClear _ = undefined + +repoPruneOptions_flags :: AttrLabelProxy "flags" +repoPruneOptions_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@reachable@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoPruneOptions #reachable +@ +-} +getRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> m (Maybe (Map.Map (Ptr ()) (Ptr ()))) +getRepoPruneOptionsReachable s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr (GHashTable (Ptr ()) (Ptr ()))) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- unpackGHashTable val' + let val''' = mapFirst ptrUnpackPtr val'' + let val'''' = mapSecond ptrUnpackPtr val''' + let val''''' = Map.fromList val'''' + return val''''' + return result + +{- | +Set the value of the “@reachable@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoPruneOptions [ #reachable 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m () +setRepoPruneOptionsReachable s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +{- | +Set the value of the “@reachable@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #reachable +@ +-} +clearRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> m () +clearRepoPruneOptionsReachable s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +#if ENABLE_OVERLOADING +data RepoPruneOptionsReachableFieldInfo +instance AttrInfo RepoPruneOptionsReachableFieldInfo where + type AttrAllowedOps RepoPruneOptionsReachableFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepoPruneOptionsReachableFieldInfo = (~) (Ptr (GHashTable (Ptr ()) (Ptr ()))) + type AttrBaseTypeConstraint RepoPruneOptionsReachableFieldInfo = (~) RepoPruneOptions + type AttrGetType RepoPruneOptionsReachableFieldInfo = Maybe (Map.Map (Ptr ()) (Ptr ())) + type AttrLabel RepoPruneOptionsReachableFieldInfo = "reachable" + type AttrOrigin RepoPruneOptionsReachableFieldInfo = RepoPruneOptions + attrGet _ = getRepoPruneOptionsReachable + attrSet _ = setRepoPruneOptionsReachable + attrConstruct = undefined + attrClear _ = clearRepoPruneOptionsReachable + +repoPruneOptions_reachable :: AttrLabelProxy "reachable" +repoPruneOptions_reachable = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "RepoPruneOptions:unused_bools" :: Not implemented: "Don't know how to unpack C array of type TCArray False 6 (-1) (TBasicType TBoolean)" +-- XXX Skipped attribute for "RepoPruneOptions:unused_ints" :: Not implemented: "Don't know how to unpack C array of type TCArray False 6 (-1) (TBasicType TInt)" +-- XXX Skipped attribute for "RepoPruneOptions:unused_ptrs" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TPtr)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoPruneOptions +type instance O.AttributeList RepoPruneOptions = RepoPruneOptionsAttributeList +type RepoPruneOptionsAttributeList = ('[ '("flags", RepoPruneOptionsFlagsFieldInfo), '("reachable", RepoPruneOptionsReachableFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoPruneOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoPruneOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoPruneOptionsMethod t RepoPruneOptions, O.MethodInfo info RepoPruneOptions p) => OL.IsLabel t (RepoPruneOptions -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoPruneOptions.hs-boot b/GI/OSTree/Structs/RepoPruneOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoPruneOptions.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoPruneOptions 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoPruneOptions = RepoPruneOptions (ManagedPtr RepoPruneOptions) +instance WrappedPtr RepoPruneOptions where diff --git a/GI/OSTree/Structs/RepoTransactionStats.hs b/GI/OSTree/Structs/RepoTransactionStats.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoTransactionStats.hs @@ -0,0 +1,648 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A list of statistics for each transaction that may be +interesting for reporting purposes. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RepoTransactionStats + ( + +-- * Exported types + RepoTransactionStats(..) , + newZeroRepoTransactionStats , + noRepoTransactionStats , + + + -- * Properties +-- ** contentBytesWritten #attr:contentBytesWritten# +{- | The amount of data added to the repository, +in bytes, counting only content objects. +-} + getRepoTransactionStatsContentBytesWritten, +#if ENABLE_OVERLOADING + repoTransactionStats_contentBytesWritten, +#endif + setRepoTransactionStatsContentBytesWritten, + + +-- ** contentObjectsTotal #attr:contentObjectsTotal# +{- | The total number of content objects +in the repository after this transaction has completed. +-} + getRepoTransactionStatsContentObjectsTotal, +#if ENABLE_OVERLOADING + repoTransactionStats_contentObjectsTotal, +#endif + setRepoTransactionStatsContentObjectsTotal, + + +-- ** contentObjectsWritten #attr:contentObjectsWritten# +{- | The number of content objects that +were written to the repository in this transaction. +-} + getRepoTransactionStatsContentObjectsWritten, +#if ENABLE_OVERLOADING + repoTransactionStats_contentObjectsWritten, +#endif + setRepoTransactionStatsContentObjectsWritten, + + +-- ** devinoCacheHits #attr:devinoCacheHits# +{- | /No description available in the introspection data./ +-} + getRepoTransactionStatsDevinoCacheHits , +#if ENABLE_OVERLOADING + repoTransactionStats_devinoCacheHits , +#endif + setRepoTransactionStatsDevinoCacheHits , + + +-- ** metadataObjectsTotal #attr:metadataObjectsTotal# +{- | The total number of metadata objects +in the repository after this transaction has completed. +-} + getRepoTransactionStatsMetadataObjectsTotal, +#if ENABLE_OVERLOADING + repoTransactionStats_metadataObjectsTotal, +#endif + setRepoTransactionStatsMetadataObjectsTotal, + + +-- ** metadataObjectsWritten #attr:metadataObjectsWritten# +{- | The number of metadata objects that +were written to the repository in this transaction. +-} + getRepoTransactionStatsMetadataObjectsWritten, +#if ENABLE_OVERLOADING + repoTransactionStats_metadataObjectsWritten, +#endif + setRepoTransactionStatsMetadataObjectsWritten, + + +-- ** padding1 #attr:padding1# +{- | reserved +-} + getRepoTransactionStatsPadding1 , +#if ENABLE_OVERLOADING + repoTransactionStats_padding1 , +#endif + setRepoTransactionStatsPadding1 , + + +-- ** padding2 #attr:padding2# +{- | reserved +-} + getRepoTransactionStatsPadding2 , +#if ENABLE_OVERLOADING + repoTransactionStats_padding2 , +#endif + setRepoTransactionStatsPadding2 , + + +-- ** padding3 #attr:padding3# +{- | reserved +-} + getRepoTransactionStatsPadding3 , +#if ENABLE_OVERLOADING + repoTransactionStats_padding3 , +#endif + setRepoTransactionStatsPadding3 , + + +-- ** padding4 #attr:padding4# +{- | reserved +-} + getRepoTransactionStatsPadding4 , +#if ENABLE_OVERLOADING + repoTransactionStats_padding4 , +#endif + setRepoTransactionStatsPadding4 , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype RepoTransactionStats = RepoTransactionStats (ManagedPtr RepoTransactionStats) +foreign import ccall "ostree_repo_transaction_stats_get_type" c_ostree_repo_transaction_stats_get_type :: + IO GType + +instance BoxedObject RepoTransactionStats where + boxedType _ = c_ostree_repo_transaction_stats_get_type + +-- | Construct a `RepoTransactionStats` struct initialized to zero. +newZeroRepoTransactionStats :: MonadIO m => m RepoTransactionStats +newZeroRepoTransactionStats = liftIO $ callocBoxedBytes 56 >>= wrapBoxed RepoTransactionStats + +instance tag ~ 'AttrSet => Constructible RepoTransactionStats tag where + new _ attrs = do + o <- newZeroRepoTransactionStats + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RepoTransactionStats`. +noRepoTransactionStats :: Maybe RepoTransactionStats +noRepoTransactionStats = Nothing + +{- | +Get the value of the “@metadata_objects_total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #metadataObjectsTotal +@ +-} +getRepoTransactionStatsMetadataObjectsTotal :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsMetadataObjectsTotal s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@metadata_objects_total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #metadataObjectsTotal 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsMetadataObjectsTotal :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsMetadataObjectsTotal s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsMetadataObjectsTotalFieldInfo +instance AttrInfo RepoTransactionStatsMetadataObjectsTotalFieldInfo where + type AttrAllowedOps RepoTransactionStatsMetadataObjectsTotalFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsMetadataObjectsTotalFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsMetadataObjectsTotalFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsMetadataObjectsTotalFieldInfo = Word32 + type AttrLabel RepoTransactionStatsMetadataObjectsTotalFieldInfo = "metadata_objects_total" + type AttrOrigin RepoTransactionStatsMetadataObjectsTotalFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsMetadataObjectsTotal + attrSet _ = setRepoTransactionStatsMetadataObjectsTotal + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_metadataObjectsTotal :: AttrLabelProxy "metadataObjectsTotal" +repoTransactionStats_metadataObjectsTotal = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@metadata_objects_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #metadataObjectsWritten +@ +-} +getRepoTransactionStatsMetadataObjectsWritten :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsMetadataObjectsWritten s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Word32 + return val + +{- | +Set the value of the “@metadata_objects_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #metadataObjectsWritten 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsMetadataObjectsWritten :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsMetadataObjectsWritten s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsMetadataObjectsWrittenFieldInfo +instance AttrInfo RepoTransactionStatsMetadataObjectsWrittenFieldInfo where + type AttrAllowedOps RepoTransactionStatsMetadataObjectsWrittenFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsMetadataObjectsWrittenFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsMetadataObjectsWrittenFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsMetadataObjectsWrittenFieldInfo = Word32 + type AttrLabel RepoTransactionStatsMetadataObjectsWrittenFieldInfo = "metadata_objects_written" + type AttrOrigin RepoTransactionStatsMetadataObjectsWrittenFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsMetadataObjectsWritten + attrSet _ = setRepoTransactionStatsMetadataObjectsWritten + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_metadataObjectsWritten :: AttrLabelProxy "metadataObjectsWritten" +repoTransactionStats_metadataObjectsWritten = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@content_objects_total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #contentObjectsTotal +@ +-} +getRepoTransactionStatsContentObjectsTotal :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsContentObjectsTotal s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +{- | +Set the value of the “@content_objects_total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #contentObjectsTotal 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsContentObjectsTotal :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsContentObjectsTotal s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsContentObjectsTotalFieldInfo +instance AttrInfo RepoTransactionStatsContentObjectsTotalFieldInfo where + type AttrAllowedOps RepoTransactionStatsContentObjectsTotalFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsContentObjectsTotalFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsContentObjectsTotalFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsContentObjectsTotalFieldInfo = Word32 + type AttrLabel RepoTransactionStatsContentObjectsTotalFieldInfo = "content_objects_total" + type AttrOrigin RepoTransactionStatsContentObjectsTotalFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsContentObjectsTotal + attrSet _ = setRepoTransactionStatsContentObjectsTotal + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_contentObjectsTotal :: AttrLabelProxy "contentObjectsTotal" +repoTransactionStats_contentObjectsTotal = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@content_objects_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #contentObjectsWritten +@ +-} +getRepoTransactionStatsContentObjectsWritten :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsContentObjectsWritten s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +{- | +Set the value of the “@content_objects_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #contentObjectsWritten 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsContentObjectsWritten :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsContentObjectsWritten s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsContentObjectsWrittenFieldInfo +instance AttrInfo RepoTransactionStatsContentObjectsWrittenFieldInfo where + type AttrAllowedOps RepoTransactionStatsContentObjectsWrittenFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsContentObjectsWrittenFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsContentObjectsWrittenFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsContentObjectsWrittenFieldInfo = Word32 + type AttrLabel RepoTransactionStatsContentObjectsWrittenFieldInfo = "content_objects_written" + type AttrOrigin RepoTransactionStatsContentObjectsWrittenFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsContentObjectsWritten + attrSet _ = setRepoTransactionStatsContentObjectsWritten + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_contentObjectsWritten :: AttrLabelProxy "contentObjectsWritten" +repoTransactionStats_contentObjectsWritten = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@content_bytes_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #contentBytesWritten +@ +-} +getRepoTransactionStatsContentBytesWritten :: MonadIO m => RepoTransactionStats -> m Word64 +getRepoTransactionStatsContentBytesWritten s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word64 + return val + +{- | +Set the value of the “@content_bytes_written@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #contentBytesWritten 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsContentBytesWritten :: MonadIO m => RepoTransactionStats -> Word64 -> m () +setRepoTransactionStatsContentBytesWritten s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Word64) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsContentBytesWrittenFieldInfo +instance AttrInfo RepoTransactionStatsContentBytesWrittenFieldInfo where + type AttrAllowedOps RepoTransactionStatsContentBytesWrittenFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsContentBytesWrittenFieldInfo = (~) Word64 + type AttrBaseTypeConstraint RepoTransactionStatsContentBytesWrittenFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsContentBytesWrittenFieldInfo = Word64 + type AttrLabel RepoTransactionStatsContentBytesWrittenFieldInfo = "content_bytes_written" + type AttrOrigin RepoTransactionStatsContentBytesWrittenFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsContentBytesWritten + attrSet _ = setRepoTransactionStatsContentBytesWritten + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_contentBytesWritten :: AttrLabelProxy "contentBytesWritten" +repoTransactionStats_contentBytesWritten = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@devino_cache_hits@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #devinoCacheHits +@ +-} +getRepoTransactionStatsDevinoCacheHits :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsDevinoCacheHits s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +{- | +Set the value of the “@devino_cache_hits@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #devinoCacheHits 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsDevinoCacheHits :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsDevinoCacheHits s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsDevinoCacheHitsFieldInfo +instance AttrInfo RepoTransactionStatsDevinoCacheHitsFieldInfo where + type AttrAllowedOps RepoTransactionStatsDevinoCacheHitsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsDevinoCacheHitsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsDevinoCacheHitsFieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsDevinoCacheHitsFieldInfo = Word32 + type AttrLabel RepoTransactionStatsDevinoCacheHitsFieldInfo = "devino_cache_hits" + type AttrOrigin RepoTransactionStatsDevinoCacheHitsFieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsDevinoCacheHits + attrSet _ = setRepoTransactionStatsDevinoCacheHits + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_devinoCacheHits :: AttrLabelProxy "devinoCacheHits" +repoTransactionStats_devinoCacheHits = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #padding1 +@ +-} +getRepoTransactionStatsPadding1 :: MonadIO m => RepoTransactionStats -> m Word32 +getRepoTransactionStatsPadding1 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Word32 + return val + +{- | +Set the value of the “@padding1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #padding1 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsPadding1 :: MonadIO m => RepoTransactionStats -> Word32 -> m () +setRepoTransactionStatsPadding1 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Word32) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsPadding1FieldInfo +instance AttrInfo RepoTransactionStatsPadding1FieldInfo where + type AttrAllowedOps RepoTransactionStatsPadding1FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsPadding1FieldInfo = (~) Word32 + type AttrBaseTypeConstraint RepoTransactionStatsPadding1FieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsPadding1FieldInfo = Word32 + type AttrLabel RepoTransactionStatsPadding1FieldInfo = "padding1" + type AttrOrigin RepoTransactionStatsPadding1FieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsPadding1 + attrSet _ = setRepoTransactionStatsPadding1 + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_padding1 :: AttrLabelProxy "padding1" +repoTransactionStats_padding1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #padding2 +@ +-} +getRepoTransactionStatsPadding2 :: MonadIO m => RepoTransactionStats -> m Word64 +getRepoTransactionStatsPadding2 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word64 + return val + +{- | +Set the value of the “@padding2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #padding2 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsPadding2 :: MonadIO m => RepoTransactionStats -> Word64 -> m () +setRepoTransactionStatsPadding2 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word64) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsPadding2FieldInfo +instance AttrInfo RepoTransactionStatsPadding2FieldInfo where + type AttrAllowedOps RepoTransactionStatsPadding2FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsPadding2FieldInfo = (~) Word64 + type AttrBaseTypeConstraint RepoTransactionStatsPadding2FieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsPadding2FieldInfo = Word64 + type AttrLabel RepoTransactionStatsPadding2FieldInfo = "padding2" + type AttrOrigin RepoTransactionStatsPadding2FieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsPadding2 + attrSet _ = setRepoTransactionStatsPadding2 + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_padding2 :: AttrLabelProxy "padding2" +repoTransactionStats_padding2 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #padding3 +@ +-} +getRepoTransactionStatsPadding3 :: MonadIO m => RepoTransactionStats -> m Word64 +getRepoTransactionStatsPadding3 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO Word64 + return val + +{- | +Set the value of the “@padding3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #padding3 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsPadding3 :: MonadIO m => RepoTransactionStats -> Word64 -> m () +setRepoTransactionStatsPadding3 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Word64) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsPadding3FieldInfo +instance AttrInfo RepoTransactionStatsPadding3FieldInfo where + type AttrAllowedOps RepoTransactionStatsPadding3FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsPadding3FieldInfo = (~) Word64 + type AttrBaseTypeConstraint RepoTransactionStatsPadding3FieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsPadding3FieldInfo = Word64 + type AttrLabel RepoTransactionStatsPadding3FieldInfo = "padding3" + type AttrOrigin RepoTransactionStatsPadding3FieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsPadding3 + attrSet _ = setRepoTransactionStatsPadding3 + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_padding3 :: AttrLabelProxy "padding3" +repoTransactionStats_padding3 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding4@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repoTransactionStats #padding4 +@ +-} +getRepoTransactionStatsPadding4 :: MonadIO m => RepoTransactionStats -> m Word64 +getRepoTransactionStatsPadding4 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO Word64 + return val + +{- | +Set the value of the “@padding4@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repoTransactionStats [ #padding4 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepoTransactionStatsPadding4 :: MonadIO m => RepoTransactionStats -> Word64 -> m () +setRepoTransactionStatsPadding4 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: Word64) + +#if ENABLE_OVERLOADING +data RepoTransactionStatsPadding4FieldInfo +instance AttrInfo RepoTransactionStatsPadding4FieldInfo where + type AttrAllowedOps RepoTransactionStatsPadding4FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RepoTransactionStatsPadding4FieldInfo = (~) Word64 + type AttrBaseTypeConstraint RepoTransactionStatsPadding4FieldInfo = (~) RepoTransactionStats + type AttrGetType RepoTransactionStatsPadding4FieldInfo = Word64 + type AttrLabel RepoTransactionStatsPadding4FieldInfo = "padding4" + type AttrOrigin RepoTransactionStatsPadding4FieldInfo = RepoTransactionStats + attrGet _ = getRepoTransactionStatsPadding4 + attrSet _ = setRepoTransactionStatsPadding4 + attrConstruct = undefined + attrClear _ = undefined + +repoTransactionStats_padding4 :: AttrLabelProxy "padding4" +repoTransactionStats_padding4 = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RepoTransactionStats +type instance O.AttributeList RepoTransactionStats = RepoTransactionStatsAttributeList +type RepoTransactionStatsAttributeList = ('[ '("metadataObjectsTotal", RepoTransactionStatsMetadataObjectsTotalFieldInfo), '("metadataObjectsWritten", RepoTransactionStatsMetadataObjectsWrittenFieldInfo), '("contentObjectsTotal", RepoTransactionStatsContentObjectsTotalFieldInfo), '("contentObjectsWritten", RepoTransactionStatsContentObjectsWrittenFieldInfo), '("contentBytesWritten", RepoTransactionStatsContentBytesWrittenFieldInfo), '("devinoCacheHits", RepoTransactionStatsDevinoCacheHitsFieldInfo), '("padding1", RepoTransactionStatsPadding1FieldInfo), '("padding2", RepoTransactionStatsPadding2FieldInfo), '("padding3", RepoTransactionStatsPadding3FieldInfo), '("padding4", RepoTransactionStatsPadding4FieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveRepoTransactionStatsMethod (t :: Symbol) (o :: *) :: * where + ResolveRepoTransactionStatsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepoTransactionStatsMethod t RepoTransactionStats, O.MethodInfo info RepoTransactionStats p) => OL.IsLabel t (RepoTransactionStats -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RepoTransactionStats.hs-boot b/GI/OSTree/Structs/RepoTransactionStats.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RepoTransactionStats.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RepoTransactionStats 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RepoTransactionStats = RepoTransactionStats (ManagedPtr RepoTransactionStats) +instance BoxedObject RepoTransactionStats where diff --git a/GI/OSTree/Structs/RollsumMatches.hs b/GI/OSTree/Structs/RollsumMatches.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RollsumMatches.hs @@ -0,0 +1,530 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.RollsumMatches + ( + +-- * Exported types + RollsumMatches(..) , + newZeroRollsumMatches , + noRollsumMatches , + + + -- * Properties +-- ** bufmatches #attr:bufmatches# +{- | /No description available in the introspection data./ +-} + getRollsumMatchesBufmatches , +#if ENABLE_OVERLOADING + rollsumMatches_bufmatches , +#endif + setRollsumMatchesBufmatches , + + +-- ** crcmatches #attr:crcmatches# +{- | /No description available in the introspection data./ +-} + getRollsumMatchesCrcmatches , +#if ENABLE_OVERLOADING + rollsumMatches_crcmatches , +#endif + setRollsumMatchesCrcmatches , + + +-- ** fromRollsums #attr:fromRollsums# +{- | /No description available in the introspection data./ +-} + clearRollsumMatchesFromRollsums , + getRollsumMatchesFromRollsums , +#if ENABLE_OVERLOADING + rollsumMatches_fromRollsums , +#endif + setRollsumMatchesFromRollsums , + + +-- ** matchSize #attr:matchSize# +{- | /No description available in the introspection data./ +-} + getRollsumMatchesMatchSize , +#if ENABLE_OVERLOADING + rollsumMatches_matchSize , +#endif + setRollsumMatchesMatchSize , + + +-- ** matches #attr:matches# +{- | /No description available in the introspection data./ +-} + clearRollsumMatchesMatches , + getRollsumMatchesMatches , +#if ENABLE_OVERLOADING + rollsumMatches_matches , +#endif + setRollsumMatchesMatches , + + +-- ** toRollsums #attr:toRollsums# +{- | /No description available in the introspection data./ +-} + clearRollsumMatchesToRollsums , + getRollsumMatchesToRollsums , +#if ENABLE_OVERLOADING + rollsumMatches_toRollsums , +#endif + setRollsumMatchesToRollsums , + + +-- ** total #attr:total# +{- | /No description available in the introspection data./ +-} + getRollsumMatchesTotal , +#if ENABLE_OVERLOADING + rollsumMatches_total , +#endif + setRollsumMatchesTotal , + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype RollsumMatches = RollsumMatches (ManagedPtr RollsumMatches) +instance WrappedPtr RollsumMatches where + wrappedPtrCalloc = callocBytes 48 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr RollsumMatches) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `RollsumMatches` struct initialized to zero. +newZeroRollsumMatches :: MonadIO m => m RollsumMatches +newZeroRollsumMatches = liftIO $ wrappedPtrCalloc >>= wrapPtr RollsumMatches + +instance tag ~ 'AttrSet => Constructible RollsumMatches tag where + new _ attrs = do + o <- newZeroRollsumMatches + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RollsumMatches`. +noRollsumMatches :: Maybe RollsumMatches +noRollsumMatches = Nothing + +{- | +Get the value of the “@from_rollsums@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #fromRollsums +@ +-} +getRollsumMatchesFromRollsums :: MonadIO m => RollsumMatches -> m (Maybe (Map.Map (Ptr ()) (Ptr ()))) +getRollsumMatchesFromRollsums s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr (GHashTable (Ptr ()) (Ptr ()))) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- unpackGHashTable val' + let val''' = mapFirst ptrUnpackPtr val'' + let val'''' = mapSecond ptrUnpackPtr val''' + let val''''' = Map.fromList val'''' + return val''''' + return result + +{- | +Set the value of the “@from_rollsums@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #fromRollsums 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesFromRollsums :: MonadIO m => RollsumMatches -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m () +setRollsumMatchesFromRollsums s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +{- | +Set the value of the “@from_rollsums@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fromRollsums +@ +-} +clearRollsumMatchesFromRollsums :: MonadIO m => RollsumMatches -> m () +clearRollsumMatchesFromRollsums s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +#if ENABLE_OVERLOADING +data RollsumMatchesFromRollsumsFieldInfo +instance AttrInfo RollsumMatchesFromRollsumsFieldInfo where + type AttrAllowedOps RollsumMatchesFromRollsumsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RollsumMatchesFromRollsumsFieldInfo = (~) (Ptr (GHashTable (Ptr ()) (Ptr ()))) + type AttrBaseTypeConstraint RollsumMatchesFromRollsumsFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesFromRollsumsFieldInfo = Maybe (Map.Map (Ptr ()) (Ptr ())) + type AttrLabel RollsumMatchesFromRollsumsFieldInfo = "from_rollsums" + type AttrOrigin RollsumMatchesFromRollsumsFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesFromRollsums + attrSet _ = setRollsumMatchesFromRollsums + attrConstruct = undefined + attrClear _ = clearRollsumMatchesFromRollsums + +rollsumMatches_fromRollsums :: AttrLabelProxy "fromRollsums" +rollsumMatches_fromRollsums = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@to_rollsums@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #toRollsums +@ +-} +getRollsumMatchesToRollsums :: MonadIO m => RollsumMatches -> m (Maybe (Map.Map (Ptr ()) (Ptr ()))) +getRollsumMatchesToRollsums s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr (GHashTable (Ptr ()) (Ptr ()))) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- unpackGHashTable val' + let val''' = mapFirst ptrUnpackPtr val'' + let val'''' = mapSecond ptrUnpackPtr val''' + let val''''' = Map.fromList val'''' + return val''''' + return result + +{- | +Set the value of the “@to_rollsums@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #toRollsums 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesToRollsums :: MonadIO m => RollsumMatches -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m () +setRollsumMatchesToRollsums s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +{- | +Set the value of the “@to_rollsums@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #toRollsums +@ +-} +clearRollsumMatchesToRollsums :: MonadIO m => RollsumMatches -> m () +clearRollsumMatchesToRollsums s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr (GHashTable (Ptr ()) (Ptr ()))) + +#if ENABLE_OVERLOADING +data RollsumMatchesToRollsumsFieldInfo +instance AttrInfo RollsumMatchesToRollsumsFieldInfo where + type AttrAllowedOps RollsumMatchesToRollsumsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RollsumMatchesToRollsumsFieldInfo = (~) (Ptr (GHashTable (Ptr ()) (Ptr ()))) + type AttrBaseTypeConstraint RollsumMatchesToRollsumsFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesToRollsumsFieldInfo = Maybe (Map.Map (Ptr ()) (Ptr ())) + type AttrLabel RollsumMatchesToRollsumsFieldInfo = "to_rollsums" + type AttrOrigin RollsumMatchesToRollsumsFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesToRollsums + attrSet _ = setRollsumMatchesToRollsums + attrConstruct = undefined + attrClear _ = clearRollsumMatchesToRollsums + +rollsumMatches_toRollsums :: AttrLabelProxy "toRollsums" +rollsumMatches_toRollsums = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@crcmatches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #crcmatches +@ +-} +getRollsumMatchesCrcmatches :: MonadIO m => RollsumMatches -> m Word32 +getRollsumMatchesCrcmatches s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +{- | +Set the value of the “@crcmatches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #crcmatches 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesCrcmatches :: MonadIO m => RollsumMatches -> Word32 -> m () +setRollsumMatchesCrcmatches s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Word32) + +#if ENABLE_OVERLOADING +data RollsumMatchesCrcmatchesFieldInfo +instance AttrInfo RollsumMatchesCrcmatchesFieldInfo where + type AttrAllowedOps RollsumMatchesCrcmatchesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RollsumMatchesCrcmatchesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RollsumMatchesCrcmatchesFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesCrcmatchesFieldInfo = Word32 + type AttrLabel RollsumMatchesCrcmatchesFieldInfo = "crcmatches" + type AttrOrigin RollsumMatchesCrcmatchesFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesCrcmatches + attrSet _ = setRollsumMatchesCrcmatches + attrConstruct = undefined + attrClear _ = undefined + +rollsumMatches_crcmatches :: AttrLabelProxy "crcmatches" +rollsumMatches_crcmatches = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@bufmatches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #bufmatches +@ +-} +getRollsumMatchesBufmatches :: MonadIO m => RollsumMatches -> m Word32 +getRollsumMatchesBufmatches s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO Word32 + return val + +{- | +Set the value of the “@bufmatches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #bufmatches 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesBufmatches :: MonadIO m => RollsumMatches -> Word32 -> m () +setRollsumMatchesBufmatches s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 20) (val :: Word32) + +#if ENABLE_OVERLOADING +data RollsumMatchesBufmatchesFieldInfo +instance AttrInfo RollsumMatchesBufmatchesFieldInfo where + type AttrAllowedOps RollsumMatchesBufmatchesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RollsumMatchesBufmatchesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RollsumMatchesBufmatchesFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesBufmatchesFieldInfo = Word32 + type AttrLabel RollsumMatchesBufmatchesFieldInfo = "bufmatches" + type AttrOrigin RollsumMatchesBufmatchesFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesBufmatches + attrSet _ = setRollsumMatchesBufmatches + attrConstruct = undefined + attrClear _ = undefined + +rollsumMatches_bufmatches :: AttrLabelProxy "bufmatches" +rollsumMatches_bufmatches = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #total +@ +-} +getRollsumMatchesTotal :: MonadIO m => RollsumMatches -> m Word32 +getRollsumMatchesTotal s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +{- | +Set the value of the “@total@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #total 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesTotal :: MonadIO m => RollsumMatches -> Word32 -> m () +setRollsumMatchesTotal s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word32) + +#if ENABLE_OVERLOADING +data RollsumMatchesTotalFieldInfo +instance AttrInfo RollsumMatchesTotalFieldInfo where + type AttrAllowedOps RollsumMatchesTotalFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RollsumMatchesTotalFieldInfo = (~) Word32 + type AttrBaseTypeConstraint RollsumMatchesTotalFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesTotalFieldInfo = Word32 + type AttrLabel RollsumMatchesTotalFieldInfo = "total" + type AttrOrigin RollsumMatchesTotalFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesTotal + attrSet _ = setRollsumMatchesTotal + attrConstruct = undefined + attrClear _ = undefined + +rollsumMatches_total :: AttrLabelProxy "total" +rollsumMatches_total = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@match_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #matchSize +@ +-} +getRollsumMatchesMatchSize :: MonadIO m => RollsumMatches -> m Word64 +getRollsumMatchesMatchSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word64 + return val + +{- | +Set the value of the “@match_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #matchSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesMatchSize :: MonadIO m => RollsumMatches -> Word64 -> m () +setRollsumMatchesMatchSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word64) + +#if ENABLE_OVERLOADING +data RollsumMatchesMatchSizeFieldInfo +instance AttrInfo RollsumMatchesMatchSizeFieldInfo where + type AttrAllowedOps RollsumMatchesMatchSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RollsumMatchesMatchSizeFieldInfo = (~) Word64 + type AttrBaseTypeConstraint RollsumMatchesMatchSizeFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesMatchSizeFieldInfo = Word64 + type AttrLabel RollsumMatchesMatchSizeFieldInfo = "match_size" + type AttrOrigin RollsumMatchesMatchSizeFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesMatchSize + attrSet _ = setRollsumMatchesMatchSize + attrConstruct = undefined + attrClear _ = undefined + +rollsumMatches_matchSize :: AttrLabelProxy "matchSize" +rollsumMatches_matchSize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@matches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rollsumMatches #matches +@ +-} +getRollsumMatchesMatches :: MonadIO m => RollsumMatches -> m (Maybe ([Ptr ()])) +getRollsumMatchesMatches s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO (Ptr (GPtrArray (Ptr ()))) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- unpackGPtrArray val' + return val'' + return result + +{- | +Set the value of the “@matches@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rollsumMatches [ #matches 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRollsumMatchesMatches :: MonadIO m => RollsumMatches -> Ptr (GPtrArray (Ptr ())) -> m () +setRollsumMatchesMatches s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Ptr (GPtrArray (Ptr ()))) + +{- | +Set the value of the “@matches@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #matches +@ +-} +clearRollsumMatchesMatches :: MonadIO m => RollsumMatches -> m () +clearRollsumMatchesMatches s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (FP.nullPtr :: Ptr (GPtrArray (Ptr ()))) + +#if ENABLE_OVERLOADING +data RollsumMatchesMatchesFieldInfo +instance AttrInfo RollsumMatchesMatchesFieldInfo where + type AttrAllowedOps RollsumMatchesMatchesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RollsumMatchesMatchesFieldInfo = (~) (Ptr (GPtrArray (Ptr ()))) + type AttrBaseTypeConstraint RollsumMatchesMatchesFieldInfo = (~) RollsumMatches + type AttrGetType RollsumMatchesMatchesFieldInfo = Maybe ([Ptr ()]) + type AttrLabel RollsumMatchesMatchesFieldInfo = "matches" + type AttrOrigin RollsumMatchesMatchesFieldInfo = RollsumMatches + attrGet _ = getRollsumMatchesMatches + attrSet _ = setRollsumMatchesMatches + attrConstruct = undefined + attrClear _ = clearRollsumMatchesMatches + +rollsumMatches_matches :: AttrLabelProxy "matches" +rollsumMatches_matches = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RollsumMatches +type instance O.AttributeList RollsumMatches = RollsumMatchesAttributeList +type RollsumMatchesAttributeList = ('[ '("fromRollsums", RollsumMatchesFromRollsumsFieldInfo), '("toRollsums", RollsumMatchesToRollsumsFieldInfo), '("crcmatches", RollsumMatchesCrcmatchesFieldInfo), '("bufmatches", RollsumMatchesBufmatchesFieldInfo), '("total", RollsumMatchesTotalFieldInfo), '("matchSize", RollsumMatchesMatchSizeFieldInfo), '("matches", RollsumMatchesMatchesFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveRollsumMatchesMethod (t :: Symbol) (o :: *) :: * where + ResolveRollsumMatchesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRollsumMatchesMethod t RollsumMatches, O.MethodInfo info RollsumMatches p) => OL.IsLabel t (RollsumMatches -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/RollsumMatches.hs-boot b/GI/OSTree/Structs/RollsumMatches.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/RollsumMatches.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.RollsumMatches 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype RollsumMatches = RollsumMatches (ManagedPtr RollsumMatches) +instance WrappedPtr RollsumMatches where diff --git a/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs b/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs @@ -0,0 +1,151 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.SysrootWriteDeploymentsOpts + ( + +-- * Exported types + SysrootWriteDeploymentsOpts(..) , + newZeroSysrootWriteDeploymentsOpts , + noSysrootWriteDeploymentsOpts , + + + -- * Properties +-- ** doPostclean #attr:doPostclean# +{- | /No description available in the introspection data./ +-} + getSysrootWriteDeploymentsOptsDoPostclean, + setSysrootWriteDeploymentsOptsDoPostclean, +#if ENABLE_OVERLOADING + sysrootWriteDeploymentsOpts_doPostclean , +#endif + + + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype SysrootWriteDeploymentsOpts = SysrootWriteDeploymentsOpts (ManagedPtr SysrootWriteDeploymentsOpts) +instance WrappedPtr SysrootWriteDeploymentsOpts where + wrappedPtrCalloc = callocBytes 120 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 120 >=> wrapPtr SysrootWriteDeploymentsOpts) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `SysrootWriteDeploymentsOpts` struct initialized to zero. +newZeroSysrootWriteDeploymentsOpts :: MonadIO m => m SysrootWriteDeploymentsOpts +newZeroSysrootWriteDeploymentsOpts = liftIO $ wrappedPtrCalloc >>= wrapPtr SysrootWriteDeploymentsOpts + +instance tag ~ 'AttrSet => Constructible SysrootWriteDeploymentsOpts tag where + new _ attrs = do + o <- newZeroSysrootWriteDeploymentsOpts + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `SysrootWriteDeploymentsOpts`. +noSysrootWriteDeploymentsOpts :: Maybe SysrootWriteDeploymentsOpts +noSysrootWriteDeploymentsOpts = Nothing + +{- | +Get the value of the “@do_postclean@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' sysrootWriteDeploymentsOpts #doPostclean +@ +-} +getSysrootWriteDeploymentsOptsDoPostclean :: MonadIO m => SysrootWriteDeploymentsOpts -> m Bool +getSysrootWriteDeploymentsOptsDoPostclean s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@do_postclean@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' sysrootWriteDeploymentsOpts [ #doPostclean 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSysrootWriteDeploymentsOptsDoPostclean :: MonadIO m => SysrootWriteDeploymentsOpts -> Bool -> m () +setSysrootWriteDeploymentsOptsDoPostclean s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CInt) + +#if ENABLE_OVERLOADING +data SysrootWriteDeploymentsOptsDoPostcleanFieldInfo +instance AttrInfo SysrootWriteDeploymentsOptsDoPostcleanFieldInfo where + type AttrAllowedOps SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = (~) Bool + type AttrBaseTypeConstraint SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = (~) SysrootWriteDeploymentsOpts + type AttrGetType SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = Bool + type AttrLabel SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = "do_postclean" + type AttrOrigin SysrootWriteDeploymentsOptsDoPostcleanFieldInfo = SysrootWriteDeploymentsOpts + attrGet _ = getSysrootWriteDeploymentsOptsDoPostclean + attrSet _ = setSysrootWriteDeploymentsOptsDoPostclean + attrConstruct = undefined + attrClear _ = undefined + +sysrootWriteDeploymentsOpts_doPostclean :: AttrLabelProxy "doPostclean" +sysrootWriteDeploymentsOpts_doPostclean = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "SysrootWriteDeploymentsOpts:unused_bools" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TBoolean)" +-- XXX Skipped attribute for "SysrootWriteDeploymentsOpts:unused_ints" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TInt)" +-- XXX Skipped attribute for "SysrootWriteDeploymentsOpts:unused_ptrs" :: Not implemented: "Don't know how to unpack C array of type TCArray False 7 (-1) (TBasicType TPtr)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SysrootWriteDeploymentsOpts +type instance O.AttributeList SysrootWriteDeploymentsOpts = SysrootWriteDeploymentsOptsAttributeList +type SysrootWriteDeploymentsOptsAttributeList = ('[ '("doPostclean", SysrootWriteDeploymentsOptsDoPostcleanFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveSysrootWriteDeploymentsOptsMethod (t :: Symbol) (o :: *) :: * where + ResolveSysrootWriteDeploymentsOptsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSysrootWriteDeploymentsOptsMethod t SysrootWriteDeploymentsOpts, O.MethodInfo info SysrootWriteDeploymentsOpts p) => OL.IsLabel t (SysrootWriteDeploymentsOpts -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs-boot b/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/SysrootWriteDeploymentsOpts.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.SysrootWriteDeploymentsOpts 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype SysrootWriteDeploymentsOpts = SysrootWriteDeploymentsOpts (ManagedPtr SysrootWriteDeploymentsOpts) +instance WrappedPtr SysrootWriteDeploymentsOpts where diff --git a/GI/OSTree/Structs/TlsCertInteraction.hs b/GI/OSTree/Structs/TlsCertInteraction.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/TlsCertInteraction.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.TlsCertInteraction + ( + +-- * Exported types + TlsCertInteraction(..) , + noTlsCertInteraction , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype TlsCertInteraction = TlsCertInteraction (ManagedPtr TlsCertInteraction) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr TlsCertInteraction where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `TlsCertInteraction`. +noTlsCertInteraction :: Maybe TlsCertInteraction +noTlsCertInteraction = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TlsCertInteraction +type instance O.AttributeList TlsCertInteraction = TlsCertInteractionAttributeList +type TlsCertInteractionAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveTlsCertInteractionMethod (t :: Symbol) (o :: *) :: * where + ResolveTlsCertInteractionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTlsCertInteractionMethod t TlsCertInteraction, O.MethodInfo info TlsCertInteraction p) => OL.IsLabel t (TlsCertInteraction -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/TlsCertInteraction.hs-boot b/GI/OSTree/Structs/TlsCertInteraction.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/TlsCertInteraction.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.TlsCertInteraction 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype TlsCertInteraction = TlsCertInteraction (ManagedPtr TlsCertInteraction) +instance WrappedPtr TlsCertInteraction where diff --git a/GI/OSTree/Structs/TlsCertInteractionClass.hs b/GI/OSTree/Structs/TlsCertInteractionClass.hs new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/TlsCertInteractionClass.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.OSTree.Structs.TlsCertInteractionClass + ( + +-- * Exported types + TlsCertInteractionClass(..) , + noTlsCertInteractionClass , + + + ) 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.ManagedPtr as B.ManagedPtr +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.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 + + +-- | Memory-managed wrapper type. +newtype TlsCertInteractionClass = TlsCertInteractionClass (ManagedPtr TlsCertInteractionClass) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr TlsCertInteractionClass where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `TlsCertInteractionClass`. +noTlsCertInteractionClass :: Maybe TlsCertInteractionClass +noTlsCertInteractionClass = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TlsCertInteractionClass +type instance O.AttributeList TlsCertInteractionClass = TlsCertInteractionClassAttributeList +type TlsCertInteractionClassAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveTlsCertInteractionClassMethod (t :: Symbol) (o :: *) :: * where + ResolveTlsCertInteractionClassMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTlsCertInteractionClassMethod t TlsCertInteractionClass, O.MethodInfo info TlsCertInteractionClass p) => OL.IsLabel t (TlsCertInteractionClass -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/OSTree/Structs/TlsCertInteractionClass.hs-boot b/GI/OSTree/Structs/TlsCertInteractionClass.hs-boot new file mode 100644 --- /dev/null +++ b/GI/OSTree/Structs/TlsCertInteractionClass.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.OSTree.Structs.TlsCertInteractionClass 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.ManagedPtr as B.ManagedPtr +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.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 + +newtype TlsCertInteractionClass = TlsCertInteractionClass (ManagedPtr TlsCertInteractionClass) +instance WrappedPtr TlsCertInteractionClass where diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-ostree library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-ostree library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-ostree libraries, or to link their applications against a +user-supplied version of gi-ostree. If you link applications to a modified +version of gi-ostree, then the changes to gi-ostree must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-ostree-1.0.6/docs/GI-OSTree.html](https://hackage.haskell.org/package/gi-ostree-1.0.6/docs/GI-OSTree.html) +[https://hackage.haskell.org/package/gi-ostree-1.0.8/docs/GI-OSTree.html](https://hackage.haskell.org/package/gi-ostree-1.0.8/docs/GI-OSTree.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-ostree.cabal b/gi-ostree.cabal --- a/gi-ostree.cabal +++ b/gi-ostree.cabal @@ -1,33 +1,33 @@ name: gi-ostree -version: 1.0.6 +version: 1.0.8 synopsis: OSTree bindings description: Bindings for OSTree, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom -cabal-version: >= 1.24 +cabal-version: 1.24 extra-source-files: README.md ChangeLog.md stack.yaml OSTree.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi == 0.21.* + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: ostree-1 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi == 0.21.*, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gio == 2.0.*, gi-gobject == 2.0.*, @@ -41,3 +41,56 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.OSTree, + GI.OSTree.Callbacks, + GI.OSTree.Constants, + GI.OSTree.Enums, + GI.OSTree.Flags, + GI.OSTree.Functions, + GI.OSTree.Interfaces, + GI.OSTree.Interfaces.RepoFinder, + GI.OSTree.Objects, + GI.OSTree.Objects.AsyncProgress, + GI.OSTree.Objects.BootconfigParser, + GI.OSTree.Objects.ChecksumInputStream, + GI.OSTree.Objects.Deployment, + GI.OSTree.Objects.GpgVerifyResult, + GI.OSTree.Objects.MutableTree, + GI.OSTree.Objects.Repo, + GI.OSTree.Objects.RepoFile, + GI.OSTree.Objects.RepoFinderAvahi, + GI.OSTree.Objects.RepoFinderConfig, + GI.OSTree.Objects.RepoFinderMount, + GI.OSTree.Objects.RepoFinderOverride, + GI.OSTree.Objects.SePolicy, + GI.OSTree.Objects.Sysroot, + GI.OSTree.Objects.SysrootUpgrader, + GI.OSTree.Structs, + GI.OSTree.Structs.Bootloader, + GI.OSTree.Structs.BootloaderGrub2, + GI.OSTree.Structs.BootloaderInterface, + GI.OSTree.Structs.BootloaderSyslinux, + GI.OSTree.Structs.BootloaderUboot, + GI.OSTree.Structs.CmdPrivateVTable, + GI.OSTree.Structs.CollectionRef, + GI.OSTree.Structs.DiffDirsOptions, + GI.OSTree.Structs.DiffItem, + GI.OSTree.Structs.GpgVerifier, + GI.OSTree.Structs.LibarchiveInputStream, + GI.OSTree.Structs.LzmaCompressor, + GI.OSTree.Structs.LzmaDecompressor, + GI.OSTree.Structs.MutableTreeIter, + GI.OSTree.Structs.Remote, + GI.OSTree.Structs.RepoCheckoutAtOptions, + GI.OSTree.Structs.RepoCommitModifier, + GI.OSTree.Structs.RepoCommitTraverseIter, + GI.OSTree.Structs.RepoDevInoCache, + GI.OSTree.Structs.RepoFileEnumerator, + GI.OSTree.Structs.RepoFinderResult, + GI.OSTree.Structs.RepoPruneOptions, + GI.OSTree.Structs.RepoTransactionStats, + GI.OSTree.Structs.RollsumMatches, + GI.OSTree.Structs.SysrootWriteDeploymentsOpts, + GI.OSTree.Structs.TlsCertInteraction, + GI.OSTree.Structs.TlsCertInteractionClass diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7