#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Ggit.Objects.Index
(
Index(..) ,
IsIndex ,
toIndex ,
noIndex ,
#if ENABLE_OVERLOADING
IndexAddMethodInfo ,
#endif
indexAdd ,
#if ENABLE_OVERLOADING
IndexAddFileMethodInfo ,
#endif
indexAddFile ,
#if ENABLE_OVERLOADING
IndexAddPathMethodInfo ,
#endif
indexAddPath ,
#if ENABLE_OVERLOADING
IndexGetEntriesMethodInfo ,
#endif
indexGetEntries ,
#if ENABLE_OVERLOADING
IndexGetEntriesResolveUndoMethodInfo ,
#endif
indexGetEntriesResolveUndo ,
#if ENABLE_OVERLOADING
IndexGetOwnerMethodInfo ,
#endif
indexGetOwner ,
#if ENABLE_OVERLOADING
IndexHasConflictsMethodInfo ,
#endif
indexHasConflicts ,
indexOpen ,
#if ENABLE_OVERLOADING
IndexReadMethodInfo ,
#endif
indexRead ,
#if ENABLE_OVERLOADING
IndexRemoveMethodInfo ,
#endif
indexRemove ,
#if ENABLE_OVERLOADING
IndexWriteMethodInfo ,
#endif
indexWrite ,
#if ENABLE_OVERLOADING
IndexWriteTreeMethodInfo ,
#endif
indexWriteTree ,
#if ENABLE_OVERLOADING
IndexWriteTreeToMethodInfo ,
#endif
indexWriteTreeTo ,
#if ENABLE_OVERLOADING
IndexFilePropertyInfo ,
#endif
constructIndexFile ,
getIndexFile ,
#if 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.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 (ManagedPtr Index)
foreign import ccall "ggit_index_get_type"
c_ggit_index_get_type :: IO GType
instance GObject Index where
gobjectType = c_ggit_index_get_type
class (GObject o, O.IsDescendantOf Index o) => IsIndex o
instance (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 :: (MonadIO m, IsIndex o) => o -> m Index
toIndex = liftIO . unsafeCastTo Index
noIndex :: Maybe Index
noIndex = Nothing
#if 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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveIndexMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveIndexMethod t Index, O.MethodInfo info Index p) => OL.IsLabel t (Index -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
getIndexFile :: (MonadIO m, IsIndex o) => o -> m (Maybe Gio.File.File)
getIndexFile obj = liftIO $ B.Properties.getObjectPropertyObject obj "file" Gio.File.File
constructIndexFile :: (IsIndex o, Gio.File.IsFile a) => a -> IO (GValueConstruct o)
constructIndexFile val = B.Properties.constructObjectPropertyObject "file" (Just val)
#if ENABLE_OVERLOADING
data IndexFilePropertyInfo
instance AttrInfo IndexFilePropertyInfo where
type AttrAllowedOps IndexFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint IndexFilePropertyInfo = Gio.File.IsFile
type AttrBaseTypeConstraint IndexFilePropertyInfo = IsIndex
type AttrGetType IndexFilePropertyInfo = (Maybe Gio.File.File)
type AttrLabel IndexFilePropertyInfo = "file"
type AttrOrigin IndexFilePropertyInfo = Index
attrGet _ = getIndexFile
attrSet _ = undefined
attrConstruct _ = constructIndexFile
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Index
type instance O.AttributeList Index = IndexAttributeList
type IndexAttributeList = ('[ '("file", IndexFilePropertyInfo), '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
indexFile :: AttrLabelProxy "file"
indexFile = AttrLabelProxy
#endif
#if 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 idx entry = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
entry' <- unsafeManagedPtrGetPtr entry
onException (do
_ <- propagateGError $ ggit_index_add idx' entry'
touchManagedPtr idx
touchManagedPtr entry
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexAddMethodInfo
instance (signature ~ (Ggit.IndexEntry.IndexEntry -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexAddMethodInfo a signature where
overloadedMethod _ = 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 idx file = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
file' <- unsafeManagedPtrCastPtr file
onException (do
_ <- propagateGError $ ggit_index_add_file idx' file'
touchManagedPtr idx
touchManagedPtr file
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexAddFileMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.MethodInfo IndexAddFileMethodInfo a signature where
overloadedMethod _ = 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 idx path = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
path' <- textToCString path
onException (do
_ <- propagateGError $ ggit_index_add_path idx' path'
touchManagedPtr idx
freeMem path'
return ()
) (do
freeMem path'
)
#if ENABLE_OVERLOADING
data IndexAddPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexAddPathMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
result <- ggit_index_get_entries idx'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.IndexEntries.IndexEntries) result'
return result''
touchManagedPtr idx
return maybeResult
#if ENABLE_OVERLOADING
data IndexGetEntriesMethodInfo
instance (signature ~ (m (Maybe Ggit.IndexEntries.IndexEntries)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetEntriesMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
result <- ggit_index_get_entries_resolve_undo idx'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo) result'
return result''
touchManagedPtr idx
return maybeResult
#if ENABLE_OVERLOADING
data IndexGetEntriesResolveUndoMethodInfo
instance (signature ~ (m (Maybe Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetEntriesResolveUndoMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
result <- ggit_index_get_owner idx'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Ggit.Repository.Repository) result'
return result''
touchManagedPtr idx
return maybeResult
#if ENABLE_OVERLOADING
data IndexGetOwnerMethodInfo
instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetOwnerMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
result <- ggit_index_has_conflicts idx'
let result' = (/= 0) result
touchManagedPtr idx
return result'
#if ENABLE_OVERLOADING
data IndexHasConflictsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsIndex a) => O.MethodInfo IndexHasConflictsMethodInfo a signature where
overloadedMethod _ = 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 idx force = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
let force' = (fromIntegral . fromEnum) force
onException (do
_ <- propagateGError $ ggit_index_read idx' force'
touchManagedPtr idx
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexReadMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexReadMethodInfo a signature where
overloadedMethod _ = 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 idx file stage = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
file' <- unsafeManagedPtrCastPtr file
onException (do
_ <- propagateGError $ ggit_index_remove idx' file' stage
touchManagedPtr idx
touchManagedPtr file
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexRemoveMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.MethodInfo IndexRemoveMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
onException (do
_ <- propagateGError $ ggit_index_write idx'
touchManagedPtr idx
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexWriteMethodInfo
instance (signature ~ (m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexWriteMethodInfo a signature where
overloadedMethod _ = 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 idx = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
onException (do
result <- propagateGError $ ggit_index_write_tree idx'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr idx
return maybeResult
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexWriteTreeMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a) => O.MethodInfo IndexWriteTreeMethodInfo a signature where
overloadedMethod _ = 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 idx repository = liftIO $ do
idx' <- unsafeManagedPtrCastPtr idx
repository' <- unsafeManagedPtrCastPtr repository
onException (do
result <- propagateGError $ ggit_index_write_tree_to idx' repository'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr idx
touchManagedPtr repository
return maybeResult
) (do
return ()
)
#if ENABLE_OVERLOADING
data IndexWriteTreeToMethodInfo
instance (signature ~ (b -> m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a, Ggit.Repository.IsRepository b) => O.MethodInfo IndexWriteTreeToMethodInfo a signature where
overloadedMethod _ = 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 file = liftIO $ do
file' <- unsafeManagedPtrCastPtr file
onException (do
result <- propagateGError $ ggit_index_open file'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Index) result'
return result''
touchManagedPtr file
return maybeResult
) (do
return ()
)
#if ENABLE_OVERLOADING
#endif