{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.Index
(
Index(..) ,
IsIndex ,
toIndex ,
#if defined(ENABLE_OVERLOADING)
ResolveIndexMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
IndexAddMethodInfo ,
#endif
indexAdd ,
#if defined(ENABLE_OVERLOADING)
IndexAddFileMethodInfo ,
#endif
indexAddFile ,
#if defined(ENABLE_OVERLOADING)
IndexAddPathMethodInfo ,
#endif
indexAddPath ,
#if defined(ENABLE_OVERLOADING)
IndexGetEntriesMethodInfo ,
#endif
indexGetEntries ,
#if defined(ENABLE_OVERLOADING)
IndexGetEntriesResolveUndoMethodInfo ,
#endif
indexGetEntriesResolveUndo ,
#if defined(ENABLE_OVERLOADING)
IndexGetOwnerMethodInfo ,
#endif
indexGetOwner ,
#if defined(ENABLE_OVERLOADING)
IndexHasConflictsMethodInfo ,
#endif
indexHasConflicts ,
indexOpen ,
#if defined(ENABLE_OVERLOADING)
IndexReadMethodInfo ,
#endif
indexRead ,
#if defined(ENABLE_OVERLOADING)
IndexRemoveMethodInfo ,
#endif
indexRemove ,
#if defined(ENABLE_OVERLOADING)
IndexWriteMethodInfo ,
#endif
indexWrite ,
#if defined(ENABLE_OVERLOADING)
IndexWriteTreeMethodInfo ,
#endif
indexWriteTree ,
#if defined(ENABLE_OVERLOADING)
IndexWriteTreeToMethodInfo ,
#endif
indexWriteTreeTo ,
#if defined(ENABLE_OVERLOADING)
IndexFilePropertyInfo ,
#endif
constructIndexFile ,
getIndexFile ,
#if defined(ENABLE_OVERLOADING)
indexFile ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository
import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntries as Ggit.IndexEntries
import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntriesResolveUndo as Ggit.IndexEntriesResolveUndo
import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntry as Ggit.IndexEntry
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
newtype Index = Index (SP.ManagedPtr Index)
deriving (Index -> Index -> Bool
(Index -> Index -> Bool) -> (Index -> Index -> Bool) -> Eq Index
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Index -> Index -> Bool
$c/= :: Index -> Index -> Bool
== :: Index -> Index -> Bool
$c== :: Index -> Index -> Bool
Eq)
instance SP.ManagedPtrNewtype Index where
toManagedPtr :: Index -> ManagedPtr Index
toManagedPtr (Index ManagedPtr Index
p) = ManagedPtr Index
p
foreign import ccall "ggit_index_get_type"
c_ggit_index_get_type :: IO B.Types.GType
instance B.Types.TypedObject Index where
glibType :: IO GType
glibType = IO GType
c_ggit_index_get_type
instance B.Types.GObject Index
class (SP.GObject o, O.IsDescendantOf Index o) => IsIndex o
instance (SP.GObject o, O.IsDescendantOf Index o) => IsIndex o
instance O.HasParentTypes Index
type instance O.ParentTypes Index = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable]
toIndex :: (MIO.MonadIO m, IsIndex o) => o -> m Index
toIndex :: forall (m :: * -> *) o. (MonadIO m, IsIndex o) => o -> m Index
toIndex = IO Index -> m Index
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Index -> m Index) -> (o -> IO Index) -> o -> m Index
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Index -> Index) -> o -> IO Index
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Index -> Index
Index
instance B.GValue.IsGValue (Maybe Index) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_index_get_type
gvalueSet_ :: Ptr GValue -> Maybe Index -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Index
P.Nothing = Ptr GValue -> Ptr Index -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Index
forall a. Ptr a
FP.nullPtr :: FP.Ptr Index)
gvalueSet_ Ptr GValue
gv (P.Just Index
obj) = Index -> (Ptr Index -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Index
obj (Ptr GValue -> Ptr Index -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Index)
gvalueGet_ Ptr GValue
gv = do
Ptr Index
ptr <- Ptr GValue -> IO (Ptr Index)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Index)
if Ptr Index
ptr Ptr Index -> Ptr Index -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Index
forall a. Ptr a
FP.nullPtr
then Index -> Maybe Index
forall a. a -> Maybe a
P.Just (Index -> Maybe Index) -> IO Index -> IO (Maybe Index)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Index -> Index) -> Ptr Index -> IO Index
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Index -> Index
Index Ptr Index
ptr
else Maybe Index -> IO (Maybe Index)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Index
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveIndexMethod (t :: Symbol) (o :: *) :: * where
ResolveIndexMethod "add" o = IndexAddMethodInfo
ResolveIndexMethod "addFile" o = IndexAddFileMethodInfo
ResolveIndexMethod "addPath" o = IndexAddPathMethodInfo
ResolveIndexMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveIndexMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveIndexMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveIndexMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveIndexMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveIndexMethod "hasConflicts" o = IndexHasConflictsMethodInfo
ResolveIndexMethod "init" o = Gio.Initable.InitableInitMethodInfo
ResolveIndexMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveIndexMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveIndexMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveIndexMethod "read" o = IndexReadMethodInfo
ResolveIndexMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveIndexMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveIndexMethod "remove" o = IndexRemoveMethodInfo
ResolveIndexMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveIndexMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveIndexMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveIndexMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveIndexMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveIndexMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveIndexMethod "write" o = IndexWriteMethodInfo
ResolveIndexMethod "writeTree" o = IndexWriteTreeMethodInfo
ResolveIndexMethod "writeTreeTo" o = IndexWriteTreeToMethodInfo
ResolveIndexMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveIndexMethod "getEntries" o = IndexGetEntriesMethodInfo
ResolveIndexMethod "getEntriesResolveUndo" o = IndexGetEntriesResolveUndoMethodInfo
ResolveIndexMethod "getOwner" o = IndexGetOwnerMethodInfo
ResolveIndexMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveIndexMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveIndexMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveIndexMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveIndexMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveIndexMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveIndexMethod t Index, O.OverloadedMethod info Index p) => OL.IsLabel t (Index -> 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 ~ ResolveIndexMethod t Index, O.OverloadedMethod info Index p, R.HasField t Index p) => R.HasField t Index p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveIndexMethod t Index, O.OverloadedMethodInfo info Index) => OL.IsLabel t (O.MethodProxy info Index) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getIndexFile :: (MonadIO m, IsIndex o) => o -> m (Maybe Gio.File.File)
getIndexFile :: forall (m :: * -> *) o.
(MonadIO m, IsIndex o) =>
o -> m (Maybe File)
getIndexFile o
obj = IO (Maybe File) -> m (Maybe File)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr File -> File) -> IO (Maybe File)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"file" ManagedPtr File -> File
Gio.File.File
constructIndexFile :: (IsIndex o, MIO.MonadIO m, Gio.File.IsFile a) => a -> m (GValueConstruct o)
constructIndexFile :: forall o (m :: * -> *) a.
(IsIndex o, MonadIO m, IsFile a) =>
a -> m (GValueConstruct o)
constructIndexFile a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"file" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data IndexFilePropertyInfo
instance AttrInfo IndexFilePropertyInfo where
type AttrAllowedOps IndexFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint IndexFilePropertyInfo = IsIndex
type AttrSetTypeConstraint IndexFilePropertyInfo = Gio.File.IsFile
type AttrTransferTypeConstraint IndexFilePropertyInfo = Gio.File.IsFile
type AttrTransferType IndexFilePropertyInfo = Gio.File.File
type AttrGetType IndexFilePropertyInfo = (Maybe Gio.File.File)
type AttrLabel IndexFilePropertyInfo = "file"
type AttrOrigin IndexFilePropertyInfo = Index
attrGet = getIndexFile
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gio.File.File v
attrConstruct = constructIndexFile
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.file"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#g:attr:file"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Index
type instance O.AttributeList Index = IndexAttributeList
type IndexAttributeList = ('[ '("file", IndexFilePropertyInfo), '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
indexFile :: AttrLabelProxy "file"
indexFile = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Index = IndexSignalList
type IndexSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_index_add" ggit_index_add ::
Ptr Index ->
Ptr Ggit.IndexEntry.IndexEntry ->
Ptr (Ptr GError) ->
IO CInt
indexAdd ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> Ggit.IndexEntry.IndexEntry
-> m ()
indexAdd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> IndexEntry -> m ()
indexAdd a
idx IndexEntry
entry = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr IndexEntry -> Ptr (Ptr GError) -> IO CInt
ggit_index_add Ptr Index
idx' Ptr IndexEntry
entry'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexAddMethodInfo
instance (signature ~ (Ggit.IndexEntry.IndexEntry -> m ()), MonadIO m, IsIndex a) => O.OverloadedMethod IndexAddMethodInfo a signature where
overloadedMethod = indexAdd
instance O.OverloadedMethodInfo IndexAddMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexAdd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexAdd"
})
#endif
foreign import ccall "ggit_index_add_file" ggit_index_add_file ::
Ptr Index ->
Ptr Gio.File.File ->
Ptr (Ptr GError) ->
IO CInt
indexAddFile ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a, Gio.File.IsFile b) =>
a
-> b
-> m ()
indexAddFile :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsIndex a, IsFile b) =>
a -> b -> m ()
indexAddFile a
idx b
file = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr File
file' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
file
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr File -> Ptr (Ptr GError) -> IO CInt
ggit_index_add_file Ptr Index
idx' Ptr File
file'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
file
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexAddFileMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.OverloadedMethod IndexAddFileMethodInfo a signature where
overloadedMethod = indexAddFile
instance O.OverloadedMethodInfo IndexAddFileMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexAddFile",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexAddFile"
})
#endif
foreign import ccall "ggit_index_add_path" ggit_index_add_path ::
Ptr Index ->
CString ->
Ptr (Ptr GError) ->
IO CInt
indexAddPath ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> T.Text
-> m ()
indexAddPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> Text -> m ()
indexAddPath a
idx Text
path = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
CString
path' <- Text -> IO CString
textToCString Text
path
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> CString -> Ptr (Ptr GError) -> IO CInt
ggit_index_add_path Ptr Index
idx' CString
path'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
)
#if defined(ENABLE_OVERLOADING)
data IndexAddPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsIndex a) => O.OverloadedMethod IndexAddPathMethodInfo a signature where
overloadedMethod = indexAddPath
instance O.OverloadedMethodInfo IndexAddPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexAddPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexAddPath"
})
#endif
foreign import ccall "ggit_index_get_entries" ggit_index_get_entries ::
Ptr Index ->
IO (Ptr Ggit.IndexEntries.IndexEntries)
indexGetEntries ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m (Maybe Ggit.IndexEntries.IndexEntries)
indexGetEntries :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m (Maybe IndexEntries)
indexGetEntries a
idx = IO (Maybe IndexEntries) -> m (Maybe IndexEntries)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IndexEntries) -> m (Maybe IndexEntries))
-> IO (Maybe IndexEntries) -> m (Maybe IndexEntries)
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr IndexEntries
result <- Ptr Index -> IO (Ptr IndexEntries)
ggit_index_get_entries Ptr Index
idx'
Maybe IndexEntries
maybeResult <- Ptr IndexEntries
-> (Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr IndexEntries
result ((Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries))
-> (Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries)
forall a b. (a -> b) -> a -> b
$ \Ptr IndexEntries
result' -> do
IndexEntries
result'' <- ((ManagedPtr IndexEntries -> IndexEntries)
-> Ptr IndexEntries -> IO IndexEntries
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IndexEntries -> IndexEntries
Ggit.IndexEntries.IndexEntries) Ptr IndexEntries
result'
IndexEntries -> IO IndexEntries
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntries
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
Maybe IndexEntries -> IO (Maybe IndexEntries)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntries
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexGetEntriesMethodInfo
instance (signature ~ (m (Maybe Ggit.IndexEntries.IndexEntries)), MonadIO m, IsIndex a) => O.OverloadedMethod IndexGetEntriesMethodInfo a signature where
overloadedMethod = indexGetEntries
instance O.OverloadedMethodInfo IndexGetEntriesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexGetEntries",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexGetEntries"
})
#endif
foreign import ccall "ggit_index_get_entries_resolve_undo" ggit_index_get_entries_resolve_undo ::
Ptr Index ->
IO (Ptr Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo)
indexGetEntriesResolveUndo ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m (Maybe Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo)
indexGetEntriesResolveUndo :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m (Maybe IndexEntriesResolveUndo)
indexGetEntriesResolveUndo a
idx = IO (Maybe IndexEntriesResolveUndo)
-> m (Maybe IndexEntriesResolveUndo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IndexEntriesResolveUndo)
-> m (Maybe IndexEntriesResolveUndo))
-> IO (Maybe IndexEntriesResolveUndo)
-> m (Maybe IndexEntriesResolveUndo)
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr IndexEntriesResolveUndo
result <- Ptr Index -> IO (Ptr IndexEntriesResolveUndo)
ggit_index_get_entries_resolve_undo Ptr Index
idx'
Maybe IndexEntriesResolveUndo
maybeResult <- Ptr IndexEntriesResolveUndo
-> (Ptr IndexEntriesResolveUndo -> IO IndexEntriesResolveUndo)
-> IO (Maybe IndexEntriesResolveUndo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr IndexEntriesResolveUndo
result ((Ptr IndexEntriesResolveUndo -> IO IndexEntriesResolveUndo)
-> IO (Maybe IndexEntriesResolveUndo))
-> (Ptr IndexEntriesResolveUndo -> IO IndexEntriesResolveUndo)
-> IO (Maybe IndexEntriesResolveUndo)
forall a b. (a -> b) -> a -> b
$ \Ptr IndexEntriesResolveUndo
result' -> do
IndexEntriesResolveUndo
result'' <- ((ManagedPtr IndexEntriesResolveUndo -> IndexEntriesResolveUndo)
-> Ptr IndexEntriesResolveUndo -> IO IndexEntriesResolveUndo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr IndexEntriesResolveUndo -> IndexEntriesResolveUndo
Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo) Ptr IndexEntriesResolveUndo
result'
IndexEntriesResolveUndo -> IO IndexEntriesResolveUndo
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntriesResolveUndo
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
Maybe IndexEntriesResolveUndo -> IO (Maybe IndexEntriesResolveUndo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntriesResolveUndo
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexGetEntriesResolveUndoMethodInfo
instance (signature ~ (m (Maybe Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo)), MonadIO m, IsIndex a) => O.OverloadedMethod IndexGetEntriesResolveUndoMethodInfo a signature where
overloadedMethod = indexGetEntriesResolveUndo
instance O.OverloadedMethodInfo IndexGetEntriesResolveUndoMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexGetEntriesResolveUndo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexGetEntriesResolveUndo"
})
#endif
foreign import ccall "ggit_index_get_owner" ggit_index_get_owner ::
Ptr Index ->
IO (Ptr Ggit.Repository.Repository)
indexGetOwner ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m (Maybe Ggit.Repository.Repository)
indexGetOwner :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m (Maybe Repository)
indexGetOwner a
idx = IO (Maybe Repository) -> m (Maybe Repository)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Repository) -> m (Maybe Repository))
-> IO (Maybe Repository) -> m (Maybe Repository)
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr Repository
result <- Ptr Index -> IO (Ptr Repository)
ggit_index_get_owner Ptr Index
idx'
Maybe Repository
maybeResult <- Ptr Repository
-> (Ptr Repository -> IO Repository) -> IO (Maybe Repository)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Repository
result ((Ptr Repository -> IO Repository) -> IO (Maybe Repository))
-> (Ptr Repository -> IO Repository) -> IO (Maybe Repository)
forall a b. (a -> b) -> a -> b
$ \Ptr Repository
result' -> do
Repository
result'' <- ((ManagedPtr Repository -> Repository)
-> Ptr Repository -> IO Repository
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repository -> Repository
Ggit.Repository.Repository) Ptr Repository
result'
Repository -> IO Repository
forall (m :: * -> *) a. Monad m => a -> m a
return Repository
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
Maybe Repository -> IO (Maybe Repository)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Repository
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexGetOwnerMethodInfo
instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsIndex a) => O.OverloadedMethod IndexGetOwnerMethodInfo a signature where
overloadedMethod = indexGetOwner
instance O.OverloadedMethodInfo IndexGetOwnerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexGetOwner",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexGetOwner"
})
#endif
foreign import ccall "ggit_index_has_conflicts" ggit_index_has_conflicts ::
Ptr Index ->
IO CInt
indexHasConflicts ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m Bool
indexHasConflicts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m Bool
indexHasConflicts a
idx = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
CInt
result <- Ptr Index -> IO CInt
ggit_index_has_conflicts Ptr Index
idx'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data IndexHasConflictsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsIndex a) => O.OverloadedMethod IndexHasConflictsMethodInfo a signature where
overloadedMethod = indexHasConflicts
instance O.OverloadedMethodInfo IndexHasConflictsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexHasConflicts",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexHasConflicts"
})
#endif
foreign import ccall "ggit_index_read" ggit_index_read ::
Ptr Index ->
CInt ->
Ptr (Ptr GError) ->
IO CInt
indexRead ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> Bool
-> m ()
indexRead :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> Bool -> m ()
indexRead a
idx Bool
force = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
let force' :: CInt
force' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
force
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> CInt -> Ptr (Ptr GError) -> IO CInt
ggit_index_read Ptr Index
idx' CInt
force'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexReadMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsIndex a) => O.OverloadedMethod IndexReadMethodInfo a signature where
overloadedMethod = indexRead
instance O.OverloadedMethodInfo IndexReadMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexRead",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexRead"
})
#endif
foreign import ccall "ggit_index_remove" ggit_index_remove ::
Ptr Index ->
Ptr Gio.File.File ->
Int32 ->
Ptr (Ptr GError) ->
IO CInt
indexRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a, Gio.File.IsFile b) =>
a
-> b
-> Int32
-> m ()
indexRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsIndex a, IsFile b) =>
a -> b -> Int32 -> m ()
indexRemove a
idx b
file Int32
stage = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr File
file' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
file
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr File -> Int32 -> Ptr (Ptr GError) -> IO CInt
ggit_index_remove Ptr Index
idx' Ptr File
file' Int32
stage
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
file
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexRemoveMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.OverloadedMethod IndexRemoveMethodInfo a signature where
overloadedMethod = indexRemove
instance O.OverloadedMethodInfo IndexRemoveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexRemove"
})
#endif
foreign import ccall "ggit_index_write" ggit_index_write ::
Ptr Index ->
Ptr (Ptr GError) ->
IO CInt
indexWrite ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m ()
indexWrite :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m ()
indexWrite a
idx = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr (Ptr GError) -> IO CInt
ggit_index_write Ptr Index
idx'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexWriteMethodInfo
instance (signature ~ (m ()), MonadIO m, IsIndex a) => O.OverloadedMethod IndexWriteMethodInfo a signature where
overloadedMethod = indexWrite
instance O.OverloadedMethodInfo IndexWriteMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexWrite",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexWrite"
})
#endif
foreign import ccall "ggit_index_write_tree" ggit_index_write_tree ::
Ptr Index ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
indexWriteTree ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a) =>
a
-> m (Maybe Ggit.OId.OId)
indexWriteTree :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsIndex a) =>
a -> m (Maybe OId)
indexWriteTree a
idx = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
IO (Maybe OId) -> IO () -> IO (Maybe OId)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr OId
result <- (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId))
-> (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr (Ptr GError) -> IO (Ptr OId)
ggit_index_write_tree Ptr Index
idx'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexWriteTreeMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a) => O.OverloadedMethod IndexWriteTreeMethodInfo a signature where
overloadedMethod = indexWriteTree
instance O.OverloadedMethodInfo IndexWriteTreeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexWriteTree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexWriteTree"
})
#endif
foreign import ccall "ggit_index_write_tree_to" ggit_index_write_tree_to ::
Ptr Index ->
Ptr Ggit.Repository.Repository ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
indexWriteTreeTo ::
(B.CallStack.HasCallStack, MonadIO m, IsIndex a, Ggit.Repository.IsRepository b) =>
a
-> b
-> m (Maybe Ggit.OId.OId)
indexWriteTreeTo :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsIndex a, IsRepository b) =>
a -> b -> m (Maybe OId)
indexWriteTreeTo a
idx b
repository = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr Index
idx' <- a -> IO (Ptr Index)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
idx
Ptr Repository
repository' <- b -> IO (Ptr Repository)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
repository
IO (Maybe OId) -> IO () -> IO (Maybe OId)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr OId
result <- (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId))
-> (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a b. (a -> b) -> a -> b
$ Ptr Index -> Ptr Repository -> Ptr (Ptr GError) -> IO (Ptr OId)
ggit_index_write_tree_to Ptr Index
idx' Ptr Repository
repository'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
idx
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
repository
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexWriteTreeToMethodInfo
instance (signature ~ (b -> m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a, Ggit.Repository.IsRepository b) => O.OverloadedMethod IndexWriteTreeToMethodInfo a signature where
overloadedMethod = indexWriteTreeTo
instance O.OverloadedMethodInfo IndexWriteTreeToMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Index.indexWriteTreeTo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Index.html#v:indexWriteTreeTo"
})
#endif
foreign import ccall "ggit_index_open" ggit_index_open ::
Ptr Gio.File.File ->
Ptr (Ptr GError) ->
IO (Ptr Index)
indexOpen ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
a
-> m (Maybe Index)
indexOpen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFile a) =>
a -> m (Maybe Index)
indexOpen a
file = IO (Maybe Index) -> m (Maybe Index)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Index) -> m (Maybe Index))
-> IO (Maybe Index) -> m (Maybe Index)
forall a b. (a -> b) -> a -> b
$ do
Ptr File
file' <- a -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
file
IO (Maybe Index) -> IO () -> IO (Maybe Index)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Index
result <- (Ptr (Ptr GError) -> IO (Ptr Index)) -> IO (Ptr Index)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Index)) -> IO (Ptr Index))
-> (Ptr (Ptr GError) -> IO (Ptr Index)) -> IO (Ptr Index)
forall a b. (a -> b) -> a -> b
$ Ptr File -> Ptr (Ptr GError) -> IO (Ptr Index)
ggit_index_open Ptr File
file'
Maybe Index
maybeResult <- Ptr Index -> (Ptr Index -> IO Index) -> IO (Maybe Index)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Index
result ((Ptr Index -> IO Index) -> IO (Maybe Index))
-> (Ptr Index -> IO Index) -> IO (Maybe Index)
forall a b. (a -> b) -> a -> b
$ \Ptr Index
result' -> do
Index
result'' <- ((ManagedPtr Index -> Index) -> Ptr Index -> IO Index
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Index -> Index
Index) Ptr Index
result'
Index -> IO Index
forall (m :: * -> *) a. Monad m => a -> m a
return Index
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
file
Maybe Index -> IO (Maybe Index)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Index
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif