{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Objects.MutableTree
(
#if defined(ENABLE_OVERLOADING)
MutableTreeGetSubdirsMethodInfo ,
#endif
MutableTree(..) ,
IsMutableTree ,
toMutableTree ,
#if defined(ENABLE_OVERLOADING)
ResolveMutableTreeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MutableTreeCheckErrorMethodInfo ,
#endif
mutableTreeCheckError ,
#if defined(ENABLE_OVERLOADING)
MutableTreeEnsureDirMethodInfo ,
#endif
mutableTreeEnsureDir ,
#if defined(ENABLE_OVERLOADING)
MutableTreeEnsureParentDirsMethodInfo ,
#endif
mutableTreeEnsureParentDirs ,
#if defined(ENABLE_OVERLOADING)
MutableTreeFillEmptyFromDirtreeMethodInfo,
#endif
mutableTreeFillEmptyFromDirtree ,
#if defined(ENABLE_OVERLOADING)
MutableTreeGetContentsChecksumMethodInfo,
#endif
mutableTreeGetContentsChecksum ,
#if defined(ENABLE_OVERLOADING)
MutableTreeGetFilesMethodInfo ,
#endif
mutableTreeGetFiles ,
#if defined(ENABLE_OVERLOADING)
MutableTreeGetMetadataChecksumMethodInfo,
#endif
mutableTreeGetMetadataChecksum ,
#if defined(ENABLE_OVERLOADING)
MutableTreeLookupMethodInfo ,
#endif
mutableTreeLookup ,
mutableTreeNew ,
mutableTreeNewFromChecksum ,
mutableTreeNewFromCommit ,
#if defined(ENABLE_OVERLOADING)
MutableTreeRemoveMethodInfo ,
#endif
mutableTreeRemove ,
#if defined(ENABLE_OVERLOADING)
MutableTreeReplaceFileMethodInfo ,
#endif
mutableTreeReplaceFile ,
#if defined(ENABLE_OVERLOADING)
MutableTreeSetContentsChecksumMethodInfo,
#endif
mutableTreeSetContentsChecksum ,
#if defined(ENABLE_OVERLOADING)
MutableTreeSetMetadataChecksumMethodInfo,
#endif
mutableTreeSetMetadataChecksum ,
#if defined(ENABLE_OVERLOADING)
MutableTreeWalkMethodInfo ,
#endif
mutableTreeWalk ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
newtype MutableTree = MutableTree (SP.ManagedPtr MutableTree)
deriving (MutableTree -> MutableTree -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MutableTree -> MutableTree -> Bool
$c/= :: MutableTree -> MutableTree -> Bool
== :: MutableTree -> MutableTree -> Bool
$c== :: MutableTree -> MutableTree -> Bool
Eq)
instance SP.ManagedPtrNewtype MutableTree where
toManagedPtr :: MutableTree -> ManagedPtr MutableTree
toManagedPtr (MutableTree ManagedPtr MutableTree
p) = ManagedPtr MutableTree
p
foreign import ccall "ostree_mutable_tree_get_type"
c_ostree_mutable_tree_get_type :: IO B.Types.GType
instance B.Types.TypedObject MutableTree where
glibType :: IO GType
glibType = IO GType
c_ostree_mutable_tree_get_type
instance B.Types.GObject MutableTree
class (SP.GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o
instance (SP.GObject o, O.IsDescendantOf MutableTree o) => IsMutableTree o
instance O.HasParentTypes MutableTree
type instance O.ParentTypes MutableTree = '[GObject.Object.Object]
toMutableTree :: (MIO.MonadIO m, IsMutableTree o) => o -> m MutableTree
toMutableTree :: forall (m :: * -> *) o.
(MonadIO m, IsMutableTree o) =>
o -> m MutableTree
toMutableTree = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr MutableTree -> MutableTree
MutableTree
instance B.GValue.IsGValue (Maybe MutableTree) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_mutable_tree_get_type
gvalueSet_ :: Ptr GValue -> Maybe MutableTree -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MutableTree
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr MutableTree)
gvalueSet_ Ptr GValue
gv (P.Just MutableTree
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MutableTree
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MutableTree)
gvalueGet_ Ptr GValue
gv = do
Ptr MutableTree
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr MutableTree)
if Ptr MutableTree
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr MutableTree -> MutableTree
MutableTree Ptr MutableTree
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveMutableTreeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveMutableTreeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMutableTreeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMutableTreeMethod "checkError" o = MutableTreeCheckErrorMethodInfo
ResolveMutableTreeMethod "ensureDir" o = MutableTreeEnsureDirMethodInfo
ResolveMutableTreeMethod "ensureParentDirs" o = MutableTreeEnsureParentDirsMethodInfo
ResolveMutableTreeMethod "fillEmptyFromDirtree" o = MutableTreeFillEmptyFromDirtreeMethodInfo
ResolveMutableTreeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMutableTreeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMutableTreeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMutableTreeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMutableTreeMethod "lookup" o = MutableTreeLookupMethodInfo
ResolveMutableTreeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMutableTreeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMutableTreeMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMutableTreeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMutableTreeMethod "remove" o = MutableTreeRemoveMethodInfo
ResolveMutableTreeMethod "replaceFile" o = MutableTreeReplaceFileMethodInfo
ResolveMutableTreeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMutableTreeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMutableTreeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMutableTreeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMutableTreeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMutableTreeMethod "walk" o = MutableTreeWalkMethodInfo
ResolveMutableTreeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMutableTreeMethod "getContentsChecksum" o = MutableTreeGetContentsChecksumMethodInfo
ResolveMutableTreeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMutableTreeMethod "getFiles" o = MutableTreeGetFilesMethodInfo
ResolveMutableTreeMethod "getMetadataChecksum" o = MutableTreeGetMetadataChecksumMethodInfo
ResolveMutableTreeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMutableTreeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMutableTreeMethod "getSubdirs" o = MutableTreeGetSubdirsMethodInfo
ResolveMutableTreeMethod "setContentsChecksum" o = MutableTreeSetContentsChecksumMethodInfo
ResolveMutableTreeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMutableTreeMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMutableTreeMethod "setMetadataChecksum" o = MutableTreeSetMetadataChecksumMethodInfo
ResolveMutableTreeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMutableTreeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMutableTreeMethod t MutableTree, O.OverloadedMethod info MutableTree p) => OL.IsLabel t (MutableTree -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMutableTreeMethod t MutableTree, O.OverloadedMethod info MutableTree p, R.HasField t MutableTree p) => R.HasField t MutableTree p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMutableTreeMethod t MutableTree, O.OverloadedMethodInfo info MutableTree) => OL.IsLabel t (O.MethodProxy info MutableTree) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MutableTree
type instance O.AttributeList MutableTree = MutableTreeAttributeList
type MutableTreeAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MutableTree = MutableTreeSignalList
type MutableTreeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "ostree_mutable_tree_new" ostree_mutable_tree_new ::
IO (Ptr MutableTree)
mutableTreeNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m MutableTree
mutableTreeNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MutableTree
mutableTreeNew = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
result <- IO (Ptr MutableTree)
ostree_mutable_tree_new
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeNew" Ptr MutableTree
result
MutableTree
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
result
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_mutable_tree_new_from_checksum" ostree_mutable_tree_new_from_checksum ::
Ptr OSTree.Repo.Repo ->
CString ->
CString ->
IO (Ptr MutableTree)
mutableTreeNewFromChecksum ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
a
-> T.Text
-> T.Text
-> m MutableTree
mutableTreeNewFromChecksum :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Text -> m MutableTree
mutableTreeNewFromChecksum a
repo Text
contentsChecksum Text
metadataChecksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
contentsChecksum' <- Text -> IO CString
textToCString Text
contentsChecksum
CString
metadataChecksum' <- Text -> IO CString
textToCString Text
metadataChecksum
Ptr MutableTree
result <- Ptr Repo -> CString -> CString -> IO (Ptr MutableTree)
ostree_mutable_tree_new_from_checksum Ptr Repo
repo' CString
contentsChecksum' CString
metadataChecksum'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeNewFromChecksum" Ptr MutableTree
result
MutableTree
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. Ptr a -> IO ()
freeMem CString
contentsChecksum'
forall a. Ptr a -> IO ()
freeMem CString
metadataChecksum'
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_mutable_tree_new_from_commit" ostree_mutable_tree_new_from_commit ::
Ptr OSTree.Repo.Repo ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr MutableTree)
mutableTreeNewFromCommit ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
a
-> T.Text
-> m MutableTree
mutableTreeNewFromCommit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> m MutableTree
mutableTreeNewFromCommit a
repo Text
rev = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
rev' <- Text -> IO CString
textToCString Text
rev
forall a b. IO a -> IO b -> IO a
onException (do
Ptr MutableTree
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> Ptr (Ptr GError) -> IO (Ptr MutableTree)
ostree_mutable_tree_new_from_commit Ptr Repo
repo' CString
rev'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeNewFromCommit" Ptr MutableTree
result
MutableTree
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. Ptr a -> IO ()
freeMem CString
rev'
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
result'
) (do
forall a. Ptr a -> IO ()
freeMem CString
rev'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_mutable_tree_check_error" ostree_mutable_tree_check_error ::
Ptr MutableTree ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeCheckError ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> m ()
mutableTreeCheckError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> m ()
mutableTreeCheckError a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
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 MutableTree -> Ptr (Ptr GError) -> IO CInt
ostree_mutable_tree_check_error Ptr MutableTree
self'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeCheckErrorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeCheckErrorMethodInfo a signature where
overloadedMethod = mutableTreeCheckError
instance O.OverloadedMethodInfo MutableTreeCheckErrorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeCheckError",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeCheckError"
})
#endif
foreign import ccall "ostree_mutable_tree_ensure_dir" ostree_mutable_tree_ensure_dir ::
Ptr MutableTree ->
CString ->
Ptr (Ptr MutableTree) ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeEnsureDir ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> m (MutableTree)
mutableTreeEnsureDir :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> m MutableTree
mutableTreeEnsureDir a
self Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (Ptr MutableTree)
outSubdir <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr MutableTree))
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 MutableTree
-> CString -> Ptr (Ptr MutableTree) -> Ptr (Ptr GError) -> IO CInt
ostree_mutable_tree_ensure_dir Ptr MutableTree
self' CString
name' Ptr (Ptr MutableTree)
outSubdir
Ptr MutableTree
outSubdir' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr MutableTree)
outSubdir
MutableTree
outSubdir'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
outSubdir'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
name'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
outSubdir''
) (do
forall a. Ptr a -> IO ()
freeMem CString
name'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeEnsureDirMethodInfo
instance (signature ~ (T.Text -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeEnsureDirMethodInfo a signature where
overloadedMethod = mutableTreeEnsureDir
instance O.OverloadedMethodInfo MutableTreeEnsureDirMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeEnsureDir",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeEnsureDir"
})
#endif
foreign import ccall "ostree_mutable_tree_ensure_parent_dirs" ostree_mutable_tree_ensure_parent_dirs ::
Ptr MutableTree ->
Ptr (GPtrArray CString) ->
CString ->
Ptr (Ptr MutableTree) ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeEnsureParentDirs ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> [T.Text]
-> T.Text
-> m (MutableTree)
mutableTreeEnsureParentDirs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> [Text] -> Text -> m MutableTree
mutableTreeEnsureParentDirs a
self [Text]
splitPath Text
metadataChecksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
[CString]
splitPath' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Text -> IO CString
textToCString [Text]
splitPath
Ptr (GPtrArray CString)
splitPath'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [CString]
splitPath'
CString
metadataChecksum' <- Text -> IO CString
textToCString Text
metadataChecksum
Ptr (Ptr MutableTree)
outParent <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr MutableTree))
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 MutableTree
-> Ptr (GPtrArray CString)
-> CString
-> Ptr (Ptr MutableTree)
-> Ptr (Ptr GError)
-> IO CInt
ostree_mutable_tree_ensure_parent_dirs Ptr MutableTree
self' Ptr (GPtrArray CString)
splitPath'' CString
metadataChecksum' Ptr (Ptr MutableTree)
outParent
Ptr MutableTree
outParent' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr MutableTree)
outParent
MutableTree
outParent'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
outParent'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a b. (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapPtrArray forall a. Ptr a -> IO ()
freeMem Ptr (GPtrArray CString)
splitPath''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
splitPath''
forall a. Ptr a -> IO ()
freeMem CString
metadataChecksum'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outParent
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
outParent''
) (do
forall a b. (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapPtrArray forall a. Ptr a -> IO ()
freeMem Ptr (GPtrArray CString)
splitPath''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
splitPath''
forall a. Ptr a -> IO ()
freeMem CString
metadataChecksum'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outParent
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeEnsureParentDirsMethodInfo
instance (signature ~ ([T.Text] -> T.Text -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeEnsureParentDirsMethodInfo a signature where
overloadedMethod = mutableTreeEnsureParentDirs
instance O.OverloadedMethodInfo MutableTreeEnsureParentDirsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeEnsureParentDirs",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeEnsureParentDirs"
})
#endif
foreign import ccall "ostree_mutable_tree_fill_empty_from_dirtree" ostree_mutable_tree_fill_empty_from_dirtree ::
Ptr MutableTree ->
Ptr OSTree.Repo.Repo ->
CString ->
CString ->
IO CInt
mutableTreeFillEmptyFromDirtree ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a, OSTree.Repo.IsRepo b) =>
a
-> b
-> T.Text
-> T.Text
-> m Bool
mutableTreeFillEmptyFromDirtree :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMutableTree a, IsRepo b) =>
a -> b -> Text -> Text -> m Bool
mutableTreeFillEmptyFromDirtree a
self b
repo Text
contentsChecksum Text
metadataChecksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
repo
CString
contentsChecksum' <- Text -> IO CString
textToCString Text
contentsChecksum
CString
metadataChecksum' <- Text -> IO CString
textToCString Text
metadataChecksum
CInt
result <- Ptr MutableTree -> Ptr Repo -> CString -> CString -> IO CInt
ostree_mutable_tree_fill_empty_from_dirtree Ptr MutableTree
self' Ptr Repo
repo' CString
contentsChecksum' CString
metadataChecksum'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
repo
forall a. Ptr a -> IO ()
freeMem CString
contentsChecksum'
forall a. Ptr a -> IO ()
freeMem CString
metadataChecksum'
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MutableTreeFillEmptyFromDirtreeMethodInfo
instance (signature ~ (b -> T.Text -> T.Text -> m Bool), MonadIO m, IsMutableTree a, OSTree.Repo.IsRepo b) => O.OverloadedMethod MutableTreeFillEmptyFromDirtreeMethodInfo a signature where
overloadedMethod = mutableTreeFillEmptyFromDirtree
instance O.OverloadedMethodInfo MutableTreeFillEmptyFromDirtreeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeFillEmptyFromDirtree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeFillEmptyFromDirtree"
})
#endif
foreign import ccall "ostree_mutable_tree_get_contents_checksum" ostree_mutable_tree_get_contents_checksum ::
Ptr MutableTree ->
IO CString
mutableTreeGetContentsChecksum ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> m T.Text
mutableTreeGetContentsChecksum :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> m Text
mutableTreeGetContentsChecksum a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr MutableTree -> IO CString
ostree_mutable_tree_get_contents_checksum Ptr MutableTree
self'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeGetContentsChecksum" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data MutableTreeGetContentsChecksumMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeGetContentsChecksumMethodInfo a signature where
overloadedMethod = mutableTreeGetContentsChecksum
instance O.OverloadedMethodInfo MutableTreeGetContentsChecksumMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeGetContentsChecksum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeGetContentsChecksum"
})
#endif
foreign import ccall "ostree_mutable_tree_get_files" ostree_mutable_tree_get_files ::
Ptr MutableTree ->
IO (Ptr (GHashTable CString CString))
mutableTreeGetFiles ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> m (Map.Map T.Text T.Text)
mutableTreeGetFiles :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> m (Map Text Text)
mutableTreeGetFiles a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr (GHashTable CString CString)
result <- Ptr MutableTree -> IO (Ptr (GHashTable CString CString))
ostree_mutable_tree_get_files Ptr MutableTree
self'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeGetFiles" Ptr (GHashTable CString CString)
result
[(PtrWrapped CString, PtrWrapped CString)]
result' <- forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
result
let result'' :: [(CString, PtrWrapped CString)]
result'' = forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
result'
[(Text, PtrWrapped CString)]
result''' <- forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
result''
let result'''' :: [(Text, CString)]
result'''' = forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(Text, PtrWrapped CString)]
result'''
[(Text, Text)]
result''''' <- forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
cstringToText [(Text, CString)]
result''''
let result'''''' :: Map Text Text
result'''''' = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result'''''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result''''''
#if defined(ENABLE_OVERLOADING)
data MutableTreeGetFilesMethodInfo
instance (signature ~ (m (Map.Map T.Text T.Text)), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeGetFilesMethodInfo a signature where
overloadedMethod = mutableTreeGetFiles
instance O.OverloadedMethodInfo MutableTreeGetFilesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeGetFiles",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeGetFiles"
})
#endif
foreign import ccall "ostree_mutable_tree_get_metadata_checksum" ostree_mutable_tree_get_metadata_checksum ::
Ptr MutableTree ->
IO CString
mutableTreeGetMetadataChecksum ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> m T.Text
mutableTreeGetMetadataChecksum :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> m Text
mutableTreeGetMetadataChecksum a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr MutableTree -> IO CString
ostree_mutable_tree_get_metadata_checksum Ptr MutableTree
self'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mutableTreeGetMetadataChecksum" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data MutableTreeGetMetadataChecksumMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeGetMetadataChecksumMethodInfo a signature where
overloadedMethod = mutableTreeGetMetadataChecksum
instance O.OverloadedMethodInfo MutableTreeGetMetadataChecksumMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeGetMetadataChecksum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeGetMetadataChecksum"
})
#endif
#if defined(ENABLE_OVERLOADING)
data MutableTreeGetSubdirsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getSubdirs" MutableTree) => O.OverloadedMethod MutableTreeGetSubdirsMethodInfo o p where
overloadedMethod = undefined
instance (o ~ O.UnsupportedMethodError "getSubdirs" MutableTree) => O.OverloadedMethodInfo MutableTreeGetSubdirsMethodInfo o where
overloadedMethodInfo = undefined
#endif
foreign import ccall "ostree_mutable_tree_lookup" ostree_mutable_tree_lookup ::
Ptr MutableTree ->
CString ->
Ptr CString ->
Ptr (Ptr MutableTree) ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeLookup ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> m ((Maybe T.Text, Maybe MutableTree))
mutableTreeLookup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> m (Maybe Text, Maybe MutableTree)
mutableTreeLookup a
self Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr CString
outFileChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr MutableTree)
outSubdir <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr MutableTree))
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 MutableTree
-> CString
-> Ptr CString
-> Ptr (Ptr MutableTree)
-> Ptr (Ptr GError)
-> IO CInt
ostree_mutable_tree_lookup Ptr MutableTree
self' CString
name' Ptr CString
outFileChecksum Ptr (Ptr MutableTree)
outSubdir
CString
outFileChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outFileChecksum
Maybe Text
maybeOutFileChecksum' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outFileChecksum' forall a b. (a -> b) -> a -> b
$ \CString
outFileChecksum'' -> do
Text
outFileChecksum''' <- HasCallStack => CString -> IO Text
cstringToText CString
outFileChecksum''
forall (m :: * -> *) a. Monad m => a -> m a
return Text
outFileChecksum'''
forall a. Ptr a -> IO ()
freeMem CString
outFileChecksum'
Ptr MutableTree
outSubdir' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr MutableTree)
outSubdir
Maybe MutableTree
maybeOutSubdir' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MutableTree
outSubdir' forall a b. (a -> b) -> a -> b
$ \Ptr MutableTree
outSubdir'' -> do
MutableTree
outSubdir''' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
outSubdir''
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
outSubdir'''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
name'
forall a. Ptr a -> IO ()
freeMem Ptr CString
outFileChecksum
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeOutFileChecksum', Maybe MutableTree
maybeOutSubdir')
) (do
forall a. Ptr a -> IO ()
freeMem CString
name'
forall a. Ptr a -> IO ()
freeMem Ptr CString
outFileChecksum
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeLookupMethodInfo
instance (signature ~ (T.Text -> m ((Maybe T.Text, Maybe MutableTree))), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeLookupMethodInfo a signature where
overloadedMethod = mutableTreeLookup
instance O.OverloadedMethodInfo MutableTreeLookupMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeLookup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeLookup"
})
#endif
foreign import ccall "ostree_mutable_tree_remove" ostree_mutable_tree_remove ::
Ptr MutableTree ->
CString ->
CInt ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> Bool
-> m ()
mutableTreeRemove :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> Bool -> m ()
mutableTreeRemove a
self Text
name Bool
allowNoent = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
name' <- Text -> IO CString
textToCString Text
name
let allowNoent' :: CInt
allowNoent' = (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
allowNoent
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 MutableTree -> CString -> CInt -> Ptr (Ptr GError) -> IO CInt
ostree_mutable_tree_remove Ptr MutableTree
self' CString
name' CInt
allowNoent'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
name'
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeRemoveMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeRemoveMethodInfo a signature where
overloadedMethod = mutableTreeRemove
instance O.OverloadedMethodInfo MutableTreeRemoveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeRemove"
})
#endif
foreign import ccall "ostree_mutable_tree_replace_file" ostree_mutable_tree_replace_file ::
Ptr MutableTree ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeReplaceFile ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> T.Text
-> m ()
mutableTreeReplaceFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> Text -> m ()
mutableTreeReplaceFile a
self Text
name Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
name' <- Text -> IO CString
textToCString Text
name
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
$ Ptr MutableTree
-> CString -> CString -> Ptr (Ptr GError) -> IO CInt
ostree_mutable_tree_replace_file Ptr MutableTree
self' CString
name' CString
checksum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
name'
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
name'
forall a. Ptr a -> IO ()
freeMem CString
checksum'
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeReplaceFileMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeReplaceFileMethodInfo a signature where
overloadedMethod = mutableTreeReplaceFile
instance O.OverloadedMethodInfo MutableTreeReplaceFileMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeReplaceFile",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeReplaceFile"
})
#endif
foreign import ccall "ostree_mutable_tree_set_contents_checksum" ostree_mutable_tree_set_contents_checksum ::
Ptr MutableTree ->
CString ->
IO ()
mutableTreeSetContentsChecksum ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> m ()
mutableTreeSetContentsChecksum :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> m ()
mutableTreeSetContentsChecksum a
self Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
Ptr MutableTree -> CString -> IO ()
ostree_mutable_tree_set_contents_checksum Ptr MutableTree
self' CString
checksum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MutableTreeSetContentsChecksumMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeSetContentsChecksumMethodInfo a signature where
overloadedMethod = mutableTreeSetContentsChecksum
instance O.OverloadedMethodInfo MutableTreeSetContentsChecksumMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeSetContentsChecksum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeSetContentsChecksum"
})
#endif
foreign import ccall "ostree_mutable_tree_set_metadata_checksum" ostree_mutable_tree_set_metadata_checksum ::
Ptr MutableTree ->
CString ->
IO ()
mutableTreeSetMetadataChecksum ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> T.Text
-> m ()
mutableTreeSetMetadataChecksum :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> Text -> m ()
mutableTreeSetMetadataChecksum a
self Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
checksum' <- Text -> IO CString
textToCString Text
checksum
Ptr MutableTree -> CString -> IO ()
ostree_mutable_tree_set_metadata_checksum Ptr MutableTree
self' CString
checksum'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
checksum'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MutableTreeSetMetadataChecksumMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeSetMetadataChecksumMethodInfo a signature where
overloadedMethod = mutableTreeSetMetadataChecksum
instance O.OverloadedMethodInfo MutableTreeSetMetadataChecksumMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeSetMetadataChecksum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeSetMetadataChecksum"
})
#endif
foreign import ccall "ostree_mutable_tree_walk" ostree_mutable_tree_walk ::
Ptr MutableTree ->
Ptr (GPtrArray CString) ->
Word32 ->
Ptr (Ptr MutableTree) ->
Ptr (Ptr GError) ->
IO CInt
mutableTreeWalk ::
(B.CallStack.HasCallStack, MonadIO m, IsMutableTree a) =>
a
-> [T.Text]
-> Word32
-> m (MutableTree)
mutableTreeWalk :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMutableTree a) =>
a -> [Text] -> Word32 -> m MutableTree
mutableTreeWalk a
self [Text]
splitPath Word32
start = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr MutableTree
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
[CString]
splitPath' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Text -> IO CString
textToCString [Text]
splitPath
Ptr (GPtrArray CString)
splitPath'' <- forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [CString]
splitPath'
Ptr (Ptr MutableTree)
outSubdir <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr MutableTree))
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 MutableTree
-> Ptr (GPtrArray CString)
-> Word32
-> Ptr (Ptr MutableTree)
-> Ptr (Ptr GError)
-> IO CInt
ostree_mutable_tree_walk Ptr MutableTree
self' Ptr (GPtrArray CString)
splitPath'' Word32
start Ptr (Ptr MutableTree)
outSubdir
Ptr MutableTree
outSubdir' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr MutableTree)
outSubdir
MutableTree
outSubdir'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MutableTree -> MutableTree
MutableTree) Ptr MutableTree
outSubdir'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a b. (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapPtrArray forall a. Ptr a -> IO ()
freeMem Ptr (GPtrArray CString)
splitPath''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
splitPath''
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
forall (m :: * -> *) a. Monad m => a -> m a
return MutableTree
outSubdir''
) (do
forall a b. (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapPtrArray forall a. Ptr a -> IO ()
freeMem Ptr (GPtrArray CString)
splitPath''
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
splitPath''
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr MutableTree)
outSubdir
)
#if defined(ENABLE_OVERLOADING)
data MutableTreeWalkMethodInfo
instance (signature ~ ([T.Text] -> Word32 -> m (MutableTree)), MonadIO m, IsMutableTree a) => O.OverloadedMethod MutableTreeWalkMethodInfo a signature where
overloadedMethod = mutableTreeWalk
instance O.OverloadedMethodInfo MutableTreeWalkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.MutableTree.mutableTreeWalk",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-MutableTree.html#v:mutableTreeWalk"
})
#endif