#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Functions
(
breakHardlink ,
checkVersion ,
checksumB64FromBytes ,
checksumB64ToBytes ,
checksumBytesPeek ,
checksumBytesPeekValidate ,
checksumFile ,
checksumFileAsync ,
checksumFileAsyncFinish ,
checksumFileAt ,
checksumFileFromInput ,
checksumFromBytes ,
checksumFromBytesV ,
checksumInplaceToBytes ,
checksumToBytes ,
checksumToBytesV ,
cmpChecksumBytes ,
commitGetContentChecksum ,
commitGetObjectSizes ,
commitGetParent ,
commitGetTimestamp ,
commitMetadataForBootable ,
contentFileParse ,
contentFileParseAt ,
contentStreamParse ,
createDirectoryMetadata ,
diffDirs ,
diffDirsWithOptions ,
diffPrint ,
fsGetAllXattrs ,
fsGetAllXattrsAt ,
gpgErrorQuark ,
hashObjectName ,
metadataVariantType ,
objectFromString ,
objectNameDeserialize ,
objectNameSerialize ,
objectToString ,
objectTypeFromString ,
objectTypeToString ,
parseRefspec ,
rawFileToArchiveZ2Stream ,
rawFileToArchiveZ2StreamWithOptions ,
rawFileToContentStream ,
validateChecksumString ,
validateCollectionId ,
validateRemoteName ,
validateRev ,
validateStructureofChecksumString ,
validateStructureofCommit ,
validateStructureofCsumV ,
validateStructureofDirmeta ,
validateStructureofDirtree ,
validateStructureofFileMode ,
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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Structs.VariantDict as GLib.VariantDict
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.CommitSizesEntry as OSTree.CommitSizesEntry
import {-# SOURCE #-} qualified GI.OSTree.Structs.DiffDirsOptions as OSTree.DiffDirsOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.DiffItem as OSTree.DiffItem
foreign import ccall "ostree_validate_structureof_objtype" ostree_validate_structureof_objtype ::
Word8 ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofObjtype ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word8
-> m ()
validateStructureofObjtype :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Word8 -> m ()
validateStructureofObjtype Word8
objtype = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Word8 -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_objtype Word8
objtype
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_file_mode" ostree_validate_structureof_file_mode ::
Word32 ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofFileMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m ()
validateStructureofFileMode :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Word32 -> m ()
validateStructureofFileMode Word32
mode = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Word32 -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_file_mode Word32
mode
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_dirtree" ostree_validate_structureof_dirtree ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofDirtree ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ()
validateStructureofDirtree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => GVariant -> m ()
validateStructureofDirtree GVariant
dirtree = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
dirtree' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
dirtree
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_dirtree Ptr GVariant
dirtree'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
dirtree
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_dirmeta" ostree_validate_structureof_dirmeta ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofDirmeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ()
validateStructureofDirmeta :: forall (m :: * -> *). (HasCallStack, MonadIO m) => GVariant -> m ()
validateStructureofDirmeta GVariant
dirmeta = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
dirmeta' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
dirmeta
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_dirmeta Ptr GVariant
dirmeta'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
dirmeta
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_csum_v" ostree_validate_structureof_csum_v ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofCsumV ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ()
validateStructureofCsumV :: forall (m :: * -> *). (HasCallStack, MonadIO m) => GVariant -> m ()
validateStructureofCsumV GVariant
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
checksum' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
checksum
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_csum_v Ptr GVariant
checksum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
checksum
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_commit" ostree_validate_structureof_commit ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofCommit ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ()
validateStructureofCommit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => GVariant -> m ()
validateStructureofCommit GVariant
commit = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
commit' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commit
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_commit Ptr GVariant
commit'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commit
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_validate_structureof_checksum_string" ostree_validate_structureof_checksum_string ::
CString ->
Ptr (Ptr GError) ->
IO CInt
validateStructureofChecksumString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
validateStructureofChecksumString :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
validateStructureofChecksumString Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
ostree_validate_structureof_checksum_string CString
checksum'
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
checksum'
)
foreign import ccall "ostree_validate_rev" ostree_validate_rev ::
CString ->
Ptr (Ptr GError) ->
IO CInt
validateRev ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
validateRev :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
validateRev Text
rev = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
rev' <- Text -> IO CString
textToCString Text
rev
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
ostree_validate_rev CString
rev'
forall a. Ptr a -> IO ()
freeMem CString
rev'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
rev'
)
foreign import ccall "ostree_validate_remote_name" ostree_validate_remote_name ::
CString ->
Ptr (Ptr GError) ->
IO CInt
validateRemoteName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
validateRemoteName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
validateRemoteName Text
remoteName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
ostree_validate_remote_name CString
remoteName'
forall a. Ptr a -> IO ()
freeMem CString
remoteName'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
remoteName'
)
foreign import ccall "ostree_validate_collection_id" ostree_validate_collection_id ::
CString ->
Ptr (Ptr GError) ->
IO CInt
validateCollectionId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m ()
validateCollectionId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m ()
validateCollectionId Maybe Text
collectionId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
maybeCollectionId <- case Maybe Text
collectionId of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jCollectionId -> do
CString
jCollectionId' <- Text -> IO CString
textToCString Text
jCollectionId
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCollectionId'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
ostree_validate_collection_id CString
maybeCollectionId
forall a. Ptr a -> IO ()
freeMem CString
maybeCollectionId
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
maybeCollectionId
)
foreign import ccall "ostree_validate_checksum_string" ostree_validate_checksum_string ::
CString ->
Ptr (Ptr GError) ->
IO CInt
validateChecksumString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
validateChecksumString :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
validateChecksumString Text
sha256 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
sha256' <- Text -> IO CString
textToCString Text
sha256
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CInt
ostree_validate_checksum_string CString
sha256'
forall a. Ptr a -> IO ()
freeMem CString
sha256'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
sha256'
)
foreign import ccall "ostree_raw_file_to_content_stream" ostree_raw_file_to_content_stream ::
Ptr Gio.InputStream.InputStream ->
Ptr Gio.FileInfo.FileInfo ->
Ptr GVariant ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr Word64 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
rawFileToContentStream ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) =>
a
-> b
-> Maybe (GVariant)
-> Maybe (c)
-> m ((Gio.InputStream.InputStream, Word64))
rawFileToContentStream :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b,
IsCancellable c) =>
a -> b -> Maybe GVariant -> Maybe c -> m (InputStream, Word64)
rawFileToContentStream a
input b
fileInfo Maybe GVariant
xattrs Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
input' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
input
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
fileInfo
Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jXattrs -> do
Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr Word64
outLength <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr FileInfo
-> Ptr GVariant
-> Ptr (Ptr InputStream)
-> Ptr Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_raw_file_to_content_stream Ptr InputStream
input' Ptr FileInfo
fileInfo' Ptr GVariant
maybeXattrs Ptr (Ptr InputStream)
outInput Ptr Word64
outLength Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
Word64
outLength' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outLength
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
input
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
fileInfo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr Word64
outLength
forall (m :: * -> *) a. Monad m => a -> m a
return (InputStream
outInput'', Word64
outLength')
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr Word64
outLength
)
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 ->
Ptr Gio.FileInfo.FileInfo ->
Ptr GVariant ->
Ptr GVariant ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
rawFileToArchiveZ2StreamWithOptions ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) =>
a
-> b
-> Maybe (GVariant)
-> Maybe (GVariant)
-> Maybe (c)
-> m (Gio.InputStream.InputStream)
rawFileToArchiveZ2StreamWithOptions :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b,
IsCancellable c) =>
a
-> b
-> Maybe GVariant
-> Maybe GVariant
-> Maybe c
-> m InputStream
rawFileToArchiveZ2StreamWithOptions a
input b
fileInfo Maybe GVariant
xattrs Maybe GVariant
options Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
input' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
input
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
fileInfo
Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jXattrs -> do
Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jOptions -> do
Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr FileInfo
-> Ptr GVariant
-> Ptr GVariant
-> Ptr (Ptr InputStream)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_raw_file_to_archive_z2_stream_with_options Ptr InputStream
input' Ptr FileInfo
fileInfo' Ptr GVariant
maybeXattrs Ptr GVariant
maybeOptions Ptr (Ptr InputStream)
outInput Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
input
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
fileInfo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
outInput''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
)
foreign import ccall "ostree_raw_file_to_archive_z2_stream" ostree_raw_file_to_archive_z2_stream ::
Ptr Gio.InputStream.InputStream ->
Ptr Gio.FileInfo.FileInfo ->
Ptr GVariant ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
rawFileToArchiveZ2Stream ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.FileInfo.IsFileInfo b, Gio.Cancellable.IsCancellable c) =>
a
-> b
-> Maybe (GVariant)
-> Maybe (c)
-> m (Gio.InputStream.InputStream)
rawFileToArchiveZ2Stream :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b,
IsCancellable c) =>
a -> b -> Maybe GVariant -> Maybe c -> m InputStream
rawFileToArchiveZ2Stream a
input b
fileInfo Maybe GVariant
xattrs Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
input' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
input
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
fileInfo
Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jXattrs -> do
Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr FileInfo
-> Ptr GVariant
-> Ptr (Ptr InputStream)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_raw_file_to_archive_z2_stream Ptr InputStream
input' Ptr FileInfo
fileInfo' Ptr GVariant
maybeXattrs Ptr (Ptr InputStream)
outInput Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
input
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
fileInfo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
outInput''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
)
foreign import ccall "ostree_parse_refspec" ostree_parse_refspec ::
CString ->
Ptr CString ->
Ptr CString ->
Ptr (Ptr GError) ->
IO CInt
parseRefspec ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Maybe T.Text, T.Text))
parseRefspec :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Text, Text)
parseRefspec Text
refspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
refspec' <- Text -> IO CString
textToCString Text
refspec
Ptr CString
outRemote <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
outRef <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString
-> Ptr CString -> Ptr CString -> Ptr (Ptr GError) -> IO CInt
ostree_parse_refspec CString
refspec' Ptr CString
outRemote Ptr CString
outRef
CString
outRemote' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outRemote
Maybe Text
maybeOutRemote' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outRemote' forall a b. (a -> b) -> a -> b
$ \CString
outRemote'' -> do
Text
outRemote''' <- HasCallStack => CString -> IO Text
cstringToText CString
outRemote''
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outRemote'''
forall a. Ptr a -> IO ()
freeMem CString
outRemote'
CString
outRef' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outRef
Text
outRef'' <- HasCallStack => CString -> IO Text
cstringToText CString
outRef'
forall a. Ptr a -> IO ()
freeMem CString
outRef'
forall a. Ptr a -> IO ()
freeMem CString
refspec'
forall a. Ptr a -> IO ()
freeMem Ptr CString
outRemote
forall a. Ptr a -> IO ()
freeMem Ptr CString
outRef
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeOutRemote', Text
outRef'')
) (do
forall a. Ptr a -> IO ()
freeMem CString
refspec'
forall a. Ptr a -> IO ()
freeMem Ptr CString
outRemote
forall a. Ptr a -> IO ()
freeMem Ptr CString
outRef
)
foreign import ccall "ostree_object_type_to_string" ostree_object_type_to_string ::
CUInt ->
IO CString
objectTypeToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
OSTree.Enums.ObjectType
-> m T.Text
objectTypeToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectType -> m Text
objectTypeToString ObjectType
objtype = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
CString
result <- CUInt -> IO CString
ostree_object_type_to_string CUInt
objtype'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectTypeToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ostree_object_type_from_string" ostree_object_type_from_string ::
CString ->
IO CUInt
objectTypeFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m OSTree.Enums.ObjectType
objectTypeFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m ObjectType
objectTypeFromString Text
str = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
CUInt
result <- CString -> IO CUInt
ostree_object_type_from_string CString
str'
let result' :: ObjectType
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. Ptr a -> IO ()
freeMem CString
str'
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectType
result'
foreign import ccall "ostree_object_to_string" ostree_object_to_string ::
CString ->
CUInt ->
IO CString
objectToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> OSTree.Enums.ObjectType
-> m T.Text
objectToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> ObjectType -> m Text
objectToString Text
checksum ObjectType
objtype = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
CString
result <- CString -> CUInt -> IO CString
ostree_object_to_string CString
checksum' CUInt
objtype'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ostree_object_name_serialize" ostree_object_name_serialize ::
CString ->
CUInt ->
IO (Ptr GVariant)
objectNameSerialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> OSTree.Enums.ObjectType
-> m GVariant
objectNameSerialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> ObjectType -> m GVariant
objectNameSerialize Text
checksum ObjectType
objtype = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
Ptr GVariant
result <- CString -> CUInt -> IO (Ptr GVariant)
ostree_object_name_serialize CString
checksum' CUInt
objtype'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectNameSerialize" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "ostree_object_name_deserialize" ostree_object_name_deserialize ::
Ptr GVariant ->
Ptr CString ->
Ptr CUInt ->
IO ()
objectNameDeserialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ((T.Text, OSTree.Enums.ObjectType))
objectNameDeserialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m (Text, ObjectType)
objectNameDeserialize GVariant
variant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
variant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
Ptr CString
outChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CUInt
outObjtype <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr GVariant -> Ptr CString -> Ptr CUInt -> IO ()
ostree_object_name_deserialize Ptr GVariant
variant' Ptr CString
outChecksum Ptr CUInt
outObjtype
CString
outChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outChecksum
Text
outChecksum'' <- HasCallStack => CString -> IO Text
cstringToText CString
outChecksum'
CUInt
outObjtype' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
outObjtype
let outObjtype'' :: ObjectType
outObjtype'' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
outObjtype'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
forall a. Ptr a -> IO ()
freeMem Ptr CString
outChecksum
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outObjtype
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
outChecksum'', ObjectType
outObjtype'')
foreign import ccall "ostree_object_from_string" ostree_object_from_string ::
CString ->
Ptr CString ->
Ptr CUInt ->
IO ()
objectFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((T.Text, OSTree.Enums.ObjectType))
objectFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Text, ObjectType)
objectFromString Text
str = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr CString
outChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CUInt
outObjtype <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CString -> Ptr CString -> Ptr CUInt -> IO ()
ostree_object_from_string CString
str' Ptr CString
outChecksum Ptr CUInt
outObjtype
CString
outChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outChecksum
Text
outChecksum'' <- HasCallStack => CString -> IO Text
cstringToText CString
outChecksum'
forall a. Ptr a -> IO ()
freeMem CString
outChecksum'
CUInt
outObjtype' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
outObjtype
let outObjtype'' :: ObjectType
outObjtype'' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
outObjtype'
forall a. Ptr a -> IO ()
freeMem CString
str'
forall a. Ptr a -> IO ()
freeMem Ptr CString
outChecksum
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outObjtype
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
outChecksum'', ObjectType
outObjtype'')
foreign import ccall "ostree_metadata_variant_type" ostree_metadata_variant_type ::
CUInt ->
IO (Ptr GLib.VariantType.VariantType)
metadataVariantType ::
(B.CallStack.HasCallStack, MonadIO m) =>
OSTree.Enums.ObjectType
-> m GLib.VariantType.VariantType
metadataVariantType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectType -> m VariantType
metadataVariantType ObjectType
objtype = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
Ptr VariantType
result <- CUInt -> IO (Ptr VariantType)
ostree_metadata_variant_type CUInt
objtype'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"metadataVariantType" Ptr VariantType
result
VariantType
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType) Ptr VariantType
result
forall (m :: * -> *) a. Monad m => a -> m a
return VariantType
result'
foreign import ccall "ostree_hash_object_name" ostree_hash_object_name ::
Ptr () ->
IO Word32
hashObjectName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m Word32
hashObjectName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> m Word32
hashObjectName Ptr ()
a = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Ptr () -> IO Word32
ostree_hash_object_name Ptr ()
a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ostree_gpg_error_quark" ostree_gpg_error_quark ::
IO Word32
gpgErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
gpgErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
gpgErrorQuark = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
ostree_gpg_error_quark
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ostree_fs_get_all_xattrs_at" ostree_fs_get_all_xattrs_at ::
Int32 ->
CString ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
fsGetAllXattrsAt ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Int32
-> T.Text
-> Maybe (a)
-> m GVariant
fsGetAllXattrsAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Text -> Maybe a -> m GVariant
fsGetAllXattrsAt Int32
dfd Text
path Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr GVariant)
ostree_fs_get_all_xattrs_at Int32
dfd CString
path' Ptr Cancellable
maybeCancellable
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fsGetAllXattrsAt" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
path'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
) (do
forall a. Ptr a -> IO ()
freeMem CString
path'
)
foreign import ccall "ostree_fs_get_all_xattrs" ostree_fs_get_all_xattrs ::
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
fsGetAllXattrs ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Int32
-> Maybe (a)
-> m GVariant
fsGetAllXattrs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Maybe a -> m GVariant
fsGetAllXattrs Int32
fd Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr GVariant)
ostree_fs_get_all_xattrs Int32
fd Ptr Cancellable
maybeCancellable
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fsGetAllXattrs" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_diff_print" ostree_diff_print ::
Ptr Gio.File.File ->
Ptr Gio.File.File ->
Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
IO ()
diffPrint ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b) =>
a
-> b
-> [OSTree.DiffItem.DiffItem]
-> [Gio.File.File]
-> [Gio.File.File]
-> m ()
diffPrint :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsFile b) =>
a -> b -> [DiffItem] -> [File] -> [File] -> m ()
diffPrint a
a b
b [DiffItem]
modified [File]
removed [File]
added = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr File
a' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
a
Ptr File
b' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
b
[Ptr DiffItem]
modified' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [DiffItem]
modified
Ptr (GPtrArray (Ptr DiffItem))
modified'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr DiffItem]
modified'
[Ptr File]
removed' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
removed
Ptr (GPtrArray (Ptr File))
removed'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
removed'
[Ptr File]
added' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
added
Ptr (GPtrArray (Ptr File))
added'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
added'
Ptr File
-> Ptr File
-> Ptr (GPtrArray (Ptr DiffItem))
-> Ptr (GPtrArray (Ptr File))
-> Ptr (GPtrArray (Ptr File))
-> IO ()
ostree_diff_print Ptr File
a' Ptr File
b' Ptr (GPtrArray (Ptr DiffItem))
modified'' Ptr (GPtrArray (Ptr File))
removed'' Ptr (GPtrArray (Ptr File))
added''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
a
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
b
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [DiffItem]
modified
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
removed
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
added
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr DiffItem))
modified''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
removed''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
added''
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ostree_diff_dirs_with_options" ostree_diff_dirs_with_options ::
CUInt ->
Ptr Gio.File.File ->
Ptr Gio.File.File ->
Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
Ptr OSTree.DiffDirsOptions.DiffDirsOptions ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
diffDirsWithOptions ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
[OSTree.Flags.DiffFlags]
-> a
-> b
-> [OSTree.DiffItem.DiffItem]
-> [Gio.File.File]
-> [Gio.File.File]
-> Maybe (OSTree.DiffDirsOptions.DiffDirsOptions)
-> Maybe (c)
-> m ()
diffDirsWithOptions :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFile a, IsFile b, IsCancellable c) =>
[DiffFlags]
-> a
-> b
-> [DiffItem]
-> [File]
-> [File]
-> Maybe DiffDirsOptions
-> Maybe c
-> m ()
diffDirsWithOptions [DiffFlags]
flags a
a b
b [DiffItem]
modified [File]
removed [File]
added Maybe DiffDirsOptions
options Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DiffFlags]
flags
Ptr File
a' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
a
Ptr File
b' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
b
[Ptr DiffItem]
modified' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [DiffItem]
modified
Ptr (GPtrArray (Ptr DiffItem))
modified'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr DiffItem]
modified'
[Ptr File]
removed' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
removed
Ptr (GPtrArray (Ptr File))
removed'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
removed'
[Ptr File]
added' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
added
Ptr (GPtrArray (Ptr File))
added'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
added'
Ptr DiffDirsOptions
maybeOptions <- case Maybe DiffDirsOptions
options of
Maybe DiffDirsOptions
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just DiffDirsOptions
jOptions -> do
Ptr DiffDirsOptions
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffDirsOptions
jOptions
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DiffDirsOptions
jOptions'
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CUInt
-> Ptr File
-> Ptr File
-> Ptr (GPtrArray (Ptr DiffItem))
-> Ptr (GPtrArray (Ptr File))
-> Ptr (GPtrArray (Ptr File))
-> Ptr DiffDirsOptions
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_diff_dirs_with_options CUInt
flags' Ptr File
a' Ptr File
b' Ptr (GPtrArray (Ptr DiffItem))
modified'' Ptr (GPtrArray (Ptr File))
removed'' Ptr (GPtrArray (Ptr File))
added'' Ptr DiffDirsOptions
maybeOptions Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
a
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
b
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [DiffItem]
modified
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
removed
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
added
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe DiffDirsOptions
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr DiffItem))
modified''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
removed''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
added''
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr DiffItem))
modified''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
removed''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
added''
)
foreign import ccall "ostree_diff_dirs" ostree_diff_dirs ::
CUInt ->
Ptr Gio.File.File ->
Ptr Gio.File.File ->
Ptr (GPtrArray (Ptr OSTree.DiffItem.DiffItem)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
Ptr (GPtrArray (Ptr Gio.File.File)) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
diffDirs ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
[OSTree.Flags.DiffFlags]
-> a
-> b
-> [OSTree.DiffItem.DiffItem]
-> [Gio.File.File]
-> [Gio.File.File]
-> Maybe (c)
-> m ()
diffDirs :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFile a, IsFile b, IsCancellable c) =>
[DiffFlags]
-> a -> b -> [DiffItem] -> [File] -> [File] -> Maybe c -> m ()
diffDirs [DiffFlags]
flags a
a b
b [DiffItem]
modified [File]
removed [File]
added Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DiffFlags]
flags
Ptr File
a' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
a
Ptr File
b' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
b
[Ptr DiffItem]
modified' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [DiffItem]
modified
Ptr (GPtrArray (Ptr DiffItem))
modified'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr DiffItem]
modified'
[Ptr File]
removed' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
removed
Ptr (GPtrArray (Ptr File))
removed'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
removed'
[Ptr File]
added' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [File]
added
Ptr (GPtrArray (Ptr File))
added'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr File]
added'
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CUInt
-> Ptr File
-> Ptr File
-> Ptr (GPtrArray (Ptr DiffItem))
-> Ptr (GPtrArray (Ptr File))
-> Ptr (GPtrArray (Ptr File))
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_diff_dirs CUInt
flags' Ptr File
a' Ptr File
b' Ptr (GPtrArray (Ptr DiffItem))
modified'' Ptr (GPtrArray (Ptr File))
removed'' Ptr (GPtrArray (Ptr File))
added'' Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
a
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
b
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [DiffItem]
modified
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
removed
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [File]
added
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr DiffItem))
modified''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
removed''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
added''
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr DiffItem))
modified''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
removed''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr File))
added''
)
foreign import ccall "ostree_create_directory_metadata" ostree_create_directory_metadata ::
Ptr Gio.FileInfo.FileInfo ->
Ptr GVariant ->
IO (Ptr GVariant)
createDirectoryMetadata ::
(B.CallStack.HasCallStack, MonadIO m, Gio.FileInfo.IsFileInfo a) =>
a
-> Maybe (GVariant)
-> m GVariant
createDirectoryMetadata :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileInfo a) =>
a -> Maybe GVariant -> m GVariant
createDirectoryMetadata a
dirInfo Maybe GVariant
xattrs = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr FileInfo
dirInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
dirInfo
Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jXattrs -> do
Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
Ptr GVariant
result <- Ptr FileInfo -> Ptr GVariant -> IO (Ptr GVariant)
ostree_create_directory_metadata Ptr FileInfo
dirInfo' Ptr GVariant
maybeXattrs
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"createDirectoryMetadata" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
dirInfo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "ostree_content_stream_parse" ostree_content_stream_parse ::
CInt ->
Ptr Gio.InputStream.InputStream ->
Word64 ->
CInt ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr (Ptr Gio.FileInfo.FileInfo) ->
Ptr (Ptr GVariant) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
contentStreamParse ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
Bool
-> a
-> Word64
-> Bool
-> Maybe (b)
-> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant))
contentStreamParse :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
Bool
-> a
-> Word64
-> Bool
-> Maybe b
-> m (InputStream, FileInfo, GVariant)
contentStreamParse Bool
compressed a
input Word64
inputLength Bool
trusted Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let compressed' :: CInt
compressed' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
compressed
Ptr InputStream
input' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
input
let trusted' :: CInt
trusted' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
trusted
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr (Ptr FileInfo)
outFileInfo <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo))
Ptr (Ptr GVariant)
outXattrs <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CInt
-> Ptr InputStream
-> Word64
-> CInt
-> Ptr (Ptr InputStream)
-> Ptr (Ptr FileInfo)
-> Ptr (Ptr GVariant)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_content_stream_parse CInt
compressed' Ptr InputStream
input' Word64
inputLength CInt
trusted' Ptr (Ptr InputStream)
outInput Ptr (Ptr FileInfo)
outFileInfo Ptr (Ptr GVariant)
outXattrs Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
Ptr FileInfo
outFileInfo' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr FileInfo)
outFileInfo
FileInfo
outFileInfo'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
outFileInfo'
Ptr GVariant
outXattrs' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outXattrs
GVariant
outXattrs'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outXattrs'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
input
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return (InputStream
outInput'', FileInfo
outFileInfo'', GVariant
outXattrs'')
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
)
foreign import ccall "ostree_content_file_parse_at" ostree_content_file_parse_at ::
CInt ->
Int32 ->
CString ->
CInt ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr (Ptr Gio.FileInfo.FileInfo) ->
Ptr (Ptr GVariant) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
contentFileParseAt ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Bool
-> Int32
-> T.Text
-> Bool
-> Maybe (a)
-> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant))
contentFileParseAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Bool
-> Int32
-> Text
-> Bool
-> Maybe a
-> m (InputStream, FileInfo, GVariant)
contentFileParseAt Bool
compressed Int32
parentDfd Text
path Bool
trusted Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let compressed' :: CInt
compressed' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
compressed
CString
path' <- Text -> IO CString
textToCString Text
path
let trusted' :: CInt
trusted' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
trusted
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr (Ptr FileInfo)
outFileInfo <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo))
Ptr (Ptr GVariant)
outXattrs <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CInt
-> Int32
-> CString
-> CInt
-> Ptr (Ptr InputStream)
-> Ptr (Ptr FileInfo)
-> Ptr (Ptr GVariant)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_content_file_parse_at CInt
compressed' Int32
parentDfd CString
path' CInt
trusted' Ptr (Ptr InputStream)
outInput Ptr (Ptr FileInfo)
outFileInfo Ptr (Ptr GVariant)
outXattrs Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
Ptr FileInfo
outFileInfo' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr FileInfo)
outFileInfo
FileInfo
outFileInfo'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
outFileInfo'
Ptr GVariant
outXattrs' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outXattrs
GVariant
outXattrs'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outXattrs'
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
path'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return (InputStream
outInput'', FileInfo
outFileInfo'', GVariant
outXattrs'')
) (do
forall a. Ptr a -> IO ()
freeMem CString
path'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
)
foreign import ccall "ostree_content_file_parse" ostree_content_file_parse ::
CInt ->
Ptr Gio.File.File ->
CInt ->
Ptr (Ptr Gio.InputStream.InputStream) ->
Ptr (Ptr Gio.FileInfo.FileInfo) ->
Ptr (Ptr GVariant) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
contentFileParse ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) =>
Bool
-> a
-> Bool
-> Maybe (b)
-> m ((Gio.InputStream.InputStream, Gio.FileInfo.FileInfo, GVariant))
contentFileParse :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsCancellable b) =>
Bool -> a -> Bool -> Maybe b -> m (InputStream, FileInfo, GVariant)
contentFileParse Bool
compressed a
contentPath Bool
trusted Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let compressed' :: CInt
compressed' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
compressed
Ptr File
contentPath' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
contentPath
let trusted' :: CInt
trusted' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
trusted
Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
Ptr (Ptr FileInfo)
outFileInfo <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo))
Ptr (Ptr GVariant)
outXattrs <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CInt
-> Ptr File
-> CInt
-> Ptr (Ptr InputStream)
-> Ptr (Ptr FileInfo)
-> Ptr (Ptr GVariant)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_content_file_parse CInt
compressed' Ptr File
contentPath' CInt
trusted' Ptr (Ptr InputStream)
outInput Ptr (Ptr FileInfo)
outFileInfo Ptr (Ptr GVariant)
outXattrs Ptr Cancellable
maybeCancellable
Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
Ptr FileInfo
outFileInfo' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr FileInfo)
outFileInfo
FileInfo
outFileInfo'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
outFileInfo'
Ptr GVariant
outXattrs' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outXattrs
GVariant
outXattrs'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outXattrs'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
contentPath
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return (InputStream
outInput'', FileInfo
outFileInfo'', GVariant
outXattrs'')
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
)
foreign import ccall "ostree_commit_metadata_for_bootable" ostree_commit_metadata_for_bootable ::
Ptr Gio.File.File ->
Ptr GLib.VariantDict.VariantDict ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
commitMetadataForBootable ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) =>
a
-> GLib.VariantDict.VariantDict
-> Maybe (b)
-> m ()
commitMetadataForBootable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsCancellable b) =>
a -> VariantDict -> Maybe b -> m ()
commitMetadataForBootable a
root VariantDict
dict Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr File
root' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
root
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr File
-> Ptr VariantDict
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_commit_metadata_for_bootable Ptr File
root' Ptr VariantDict
dict' Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
root
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_commit_get_timestamp" ostree_commit_get_timestamp ::
Ptr GVariant ->
IO Word64
commitGetTimestamp ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m Word64
commitGetTimestamp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Word64
commitGetTimestamp GVariant
commitVariant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
commitVariant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commitVariant
Word64
result <- Ptr GVariant -> IO Word64
ostree_commit_get_timestamp Ptr GVariant
commitVariant'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commitVariant
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
foreign import ccall "ostree_commit_get_parent" ostree_commit_get_parent ::
Ptr GVariant ->
IO CString
commitGetParent ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m (Maybe T.Text)
commitGetParent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m (Maybe Text)
commitGetParent GVariant
commitVariant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
commitVariant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commitVariant
CString
result <- Ptr GVariant -> IO CString
ostree_commit_get_parent Ptr GVariant
commitVariant'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commitVariant
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "ostree_commit_get_object_sizes" ostree_commit_get_object_sizes ::
Ptr GVariant ->
Ptr (Ptr (GPtrArray (Ptr OSTree.CommitSizesEntry.CommitSizesEntry))) ->
Ptr (Ptr GError) ->
IO CInt
commitGetObjectSizes ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ([OSTree.CommitSizesEntry.CommitSizesEntry])
commitGetObjectSizes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m [CommitSizesEntry]
commitGetObjectSizes GVariant
commitVariant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
commitVariant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commitVariant
Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
outSizesEntries <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GPtrArray (Ptr OSTree.CommitSizesEntry.CommitSizesEntry))))
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant
-> Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
-> Ptr (Ptr GError)
-> IO CInt
ostree_commit_get_object_sizes Ptr GVariant
commitVariant' Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
outSizesEntries
Ptr (GPtrArray (Ptr CommitSizesEntry))
outSizesEntries' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
outSizesEntries
[Ptr CommitSizesEntry]
outSizesEntries'' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr CommitSizesEntry))
outSizesEntries'
[CommitSizesEntry]
outSizesEntries''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr CommitSizesEntry -> CommitSizesEntry
OSTree.CommitSizesEntry.CommitSizesEntry) [Ptr CommitSizesEntry]
outSizesEntries''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr CommitSizesEntry))
outSizesEntries'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commitVariant
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
outSizesEntries
forall (m :: * -> *) a. Monad m => a -> m a
return [CommitSizesEntry]
outSizesEntries'''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray (Ptr CommitSizesEntry)))
outSizesEntries
)
foreign import ccall "ostree_commit_get_content_checksum" ostree_commit_get_content_checksum ::
Ptr GVariant ->
IO CString
commitGetContentChecksum ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m (Maybe T.Text)
commitGetContentChecksum :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m (Maybe Text)
commitGetContentChecksum GVariant
commitVariant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
commitVariant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commitVariant
CString
result <- Ptr GVariant -> IO CString
ostree_commit_get_content_checksum Ptr GVariant
commitVariant'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commitVariant
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "ostree_cmp_checksum_bytes" ostree_cmp_checksum_bytes ::
Word8 ->
Word8 ->
IO Int32
cmpChecksumBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word8
-> Word8
-> m Int32
cmpChecksumBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word8 -> Word8 -> m Int32
cmpChecksumBytes Word8
a Word8
b = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Int32
result <- Word8 -> Word8 -> IO Int32
ostree_cmp_checksum_bytes Word8
a Word8
b
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "ostree_checksum_to_bytes_v" ostree_checksum_to_bytes_v ::
CString ->
IO (Ptr GVariant)
checksumToBytesV ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m GVariant
checksumToBytesV :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m GVariant
checksumToBytesV Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
Ptr GVariant
result <- CString -> IO (Ptr GVariant)
ostree_checksum_to_bytes_v CString
checksum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumToBytesV" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "ostree_checksum_to_bytes" ostree_checksum_to_bytes ::
CString ->
IO (Ptr Word8)
checksumToBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ByteString
checksumToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m ByteString
checksumToBytes Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
Ptr Word8
result <- CString -> IO (Ptr Word8)
ostree_checksum_to_bytes CString
checksum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumToBytes" Ptr Word8
result
ByteString
result' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
result
forall a. Ptr a -> IO ()
freeMem Ptr Word8
result
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
foreign import ccall "ostree_checksum_inplace_to_bytes" ostree_checksum_inplace_to_bytes ::
CString ->
Word8 ->
IO ()
checksumInplaceToBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Word8
-> m ()
checksumInplaceToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Word8 -> m ()
checksumInplaceToBytes Text
checksum Word8
buf = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
CString -> Word8 -> IO ()
ostree_checksum_inplace_to_bytes CString
checksum' Word8
buf
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ostree_checksum_from_bytes_v" ostree_checksum_from_bytes_v ::
Ptr GVariant ->
IO CString
checksumFromBytesV ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m T.Text
checksumFromBytesV :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Text
checksumFromBytesV GVariant
csumV = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
csumV' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
csumV
CString
result <- Ptr GVariant -> IO CString
ostree_checksum_from_bytes_v Ptr GVariant
csumV'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumFromBytesV" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
csumV
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ostree_checksum_from_bytes" ostree_checksum_from_bytes ::
Ptr Word8 ->
IO CString
checksumFromBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m T.Text
checksumFromBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Text
checksumFromBytes ByteString
csum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Word8
csum' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
csum
CString
result <- Ptr Word8 -> IO CString
ostree_checksum_from_bytes Ptr Word8
csum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumFromBytes" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. Ptr a -> IO ()
freeMem Ptr Word8
csum'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ostree_checksum_file_from_input" ostree_checksum_file_from_input ::
Ptr Gio.FileInfo.FileInfo ->
Ptr GVariant ->
Ptr Gio.InputStream.InputStream ->
CUInt ->
Ptr (Ptr Word8) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
checksumFileFromInput ::
(B.CallStack.HasCallStack, MonadIO m, Gio.FileInfo.IsFileInfo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
a
-> Maybe (GVariant)
-> Maybe (b)
-> OSTree.Enums.ObjectType
-> Maybe (c)
-> m (ByteString)
checksumFileFromInput :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFileInfo a, IsInputStream b,
IsCancellable c) =>
a
-> Maybe GVariant
-> Maybe b
-> ObjectType
-> Maybe c
-> m ByteString
checksumFileFromInput a
fileInfo Maybe GVariant
xattrs Maybe b
in_ ObjectType
objtype Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fileInfo
Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jXattrs -> do
Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
Ptr InputStream
maybeIn_ <- case Maybe b
in_ of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jIn_ -> do
Ptr InputStream
jIn_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jIn_
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
jIn_'
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr FileInfo
-> Ptr GVariant
-> Ptr InputStream
-> CUInt
-> Ptr (Ptr Word8)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_checksum_file_from_input Ptr FileInfo
fileInfo' Ptr GVariant
maybeXattrs Ptr InputStream
maybeIn_ CUInt
objtype' Ptr (Ptr Word8)
outCsum Ptr Cancellable
maybeCancellable
Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fileInfo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
in_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
)
foreign import ccall "ostree_checksum_file_at" ostree_checksum_file_at ::
Int32 ->
CString ->
Ptr () ->
CUInt ->
CUInt ->
CString ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
checksumFileAt ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Int32
-> T.Text
-> Ptr ()
-> OSTree.Enums.ObjectType
-> [OSTree.Flags.ChecksumFlags]
-> T.Text
-> Maybe (a)
-> m ()
checksumFileAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32
-> Text
-> Ptr ()
-> ObjectType
-> [ChecksumFlags]
-> Text
-> Maybe a
-> m ()
checksumFileAt Int32
dfd Text
path Ptr ()
stbuf ObjectType
objtype [ChecksumFlags]
flags Text
outChecksum Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ChecksumFlags]
flags
CString
outChecksum' <- Text -> IO CString
textToCString Text
outChecksum
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32
-> CString
-> Ptr ()
-> CUInt
-> CUInt
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_checksum_file_at Int32
dfd CString
path' Ptr ()
stbuf CUInt
objtype' CUInt
flags' CString
outChecksum' Ptr Cancellable
maybeCancellable
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
path'
forall a. Ptr a -> IO ()
freeMem CString
outChecksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
path'
forall a. Ptr a -> IO ()
freeMem CString
outChecksum'
)
foreign import ccall "ostree_checksum_file_async_finish" ostree_checksum_file_async_finish ::
Ptr Gio.File.File ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr Word8) ->
Ptr (Ptr GError) ->
IO CInt
checksumFileAsyncFinish ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m (ByteString)
checksumFileAsyncFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsAsyncResult b) =>
a -> b -> m ByteString
checksumFileAsyncFinish a
f b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr File
f' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
f
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr File
-> Ptr AsyncResult
-> Ptr (Ptr Word8)
-> Ptr (Ptr GError)
-> IO CInt
ostree_checksum_file_async_finish Ptr File
f' Ptr AsyncResult
result_' Ptr (Ptr Word8)
outCsum
Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
f
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
)
foreign import ccall "ostree_checksum_file_async" ostree_checksum_file_async ::
Ptr Gio.File.File ->
CUInt ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
checksumFileAsync ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) =>
a
-> OSTree.Enums.ObjectType
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
checksumFileAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsCancellable b) =>
a
-> ObjectType
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
checksumFileAsync a
f ObjectType
objtype Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr File
f' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
f
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr File
-> CUInt
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ostree_checksum_file_async Ptr File
f' CUInt
objtype' Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
f
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ostree_checksum_file" ostree_checksum_file ::
Ptr Gio.File.File ->
CUInt ->
Ptr (Ptr Word8) ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
checksumFile ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) =>
a
-> OSTree.Enums.ObjectType
-> Maybe (b)
-> m (ByteString)
checksumFile :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsCancellable b) =>
a -> ObjectType -> Maybe b -> m ByteString
checksumFile a
f ObjectType
objtype Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr File
f' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
f
let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr File
-> CUInt
-> Ptr (Ptr Word8)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_checksum_file Ptr File
f' CUInt
objtype' Ptr (Ptr Word8)
outCsum Ptr Cancellable
maybeCancellable
Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
f
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
)
foreign import ccall "ostree_checksum_bytes_peek_validate" ostree_checksum_bytes_peek_validate ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO (Ptr Word8)
checksumBytesPeekValidate ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ByteString
checksumBytesPeekValidate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m ByteString
checksumBytesPeekValidate GVariant
bytes = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
bytes' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
bytes
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Word8
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO (Ptr Word8)
ostree_checksum_bytes_peek_validate Ptr GVariant
bytes'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumBytesPeekValidate" Ptr Word8
result
ByteString
result' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
bytes
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "ostree_checksum_bytes_peek" ostree_checksum_bytes_peek ::
Ptr GVariant ->
IO (Ptr Word8)
checksumBytesPeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ByteString
checksumBytesPeek :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m ByteString
checksumBytesPeek GVariant
bytes = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
bytes' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
bytes
Ptr Word8
result <- Ptr GVariant -> IO (Ptr Word8)
ostree_checksum_bytes_peek Ptr GVariant
bytes'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumBytesPeek" Ptr Word8
result
ByteString
result' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
bytes
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
foreign import ccall "ostree_checksum_b64_to_bytes" ostree_checksum_b64_to_bytes ::
CString ->
IO (Ptr Word8)
checksumB64ToBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ByteString
checksumB64ToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m ByteString
checksumB64ToBytes Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
Ptr Word8
result <- CString -> IO (Ptr Word8)
ostree_checksum_b64_to_bytes CString
checksum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumB64ToBytes" Ptr Word8
result
ByteString
result' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
result
forall a. Ptr a -> IO ()
freeMem Ptr Word8
result
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
foreign import ccall "ostree_checksum_b64_from_bytes" ostree_checksum_b64_from_bytes ::
Ptr Word8 ->
IO CString
checksumB64FromBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m T.Text
checksumB64FromBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Text
checksumB64FromBytes ByteString
csum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Word8
csum' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
csum
CString
result <- Ptr Word8 -> IO CString
ostree_checksum_b64_from_bytes Ptr Word8
csum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumB64FromBytes" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. Ptr a -> IO ()
freeMem Ptr Word8
csum'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ostree_check_version" ostree_check_version ::
Word32 ->
Word32 ->
IO CInt
checkVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Word32
-> m Bool
checkVersion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Word32 -> m Bool
checkVersion Word32
requiredYear Word32
requiredRelease = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CInt
result <- Word32 -> Word32 -> IO CInt
ostree_check_version Word32
requiredYear Word32
requiredRelease
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "ostree_break_hardlink" ostree_break_hardlink ::
Int32 ->
CString ->
CInt ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
breakHardlink ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Int32
-> T.Text
-> Bool
-> Maybe (a)
-> m ()
breakHardlink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Text -> Bool -> Maybe a -> m ()
breakHardlink Int32
dfd Text
path Bool
skipXattrs Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
let skipXattrs' :: CInt
skipXattrs' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
skipXattrs
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32
-> CString
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_break_hardlink Int32
dfd CString
path' CInt
skipXattrs' Ptr Cancellable
maybeCancellable
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
path'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
path'
)