Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.Ggit.Callbacks

Contents

Signals

Description

Synopsis

type C_ConfigCallback = Ptr ConfigEntry -> Ptr () -> IO Int32
type ConfigCallback = ConfigEntry -> IO Int32
type ConfigCallback_WithClosures = ConfigEntry -> Ptr () -> IO Int32
drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures
dynamic_ConfigCallback :: (HasCallStack, MonadIO m) => FunPtr C_ConfigCallback -> ConfigEntry -> Ptr () -> m Int32
genClosure_ConfigCallback :: ConfigCallback -> IO Closure
mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback)
noConfigCallback :: Maybe ConfigCallback
noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures
wrap_ConfigCallback :: Maybe (Ptr (FunPtr C_ConfigCallback)) -> ConfigCallback_WithClosures -> C_ConfigCallback
type C_ConfigMatchCallback = Ptr MatchInfo -> CString -> Ptr () -> IO Int32
type ConfigMatchCallback = MatchInfo -> Text -> IO Int32
type ConfigMatchCallback_WithClosures = MatchInfo -> Text -> Ptr () -> IO Int32
drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures
dynamic_ConfigMatchCallback :: (HasCallStack, MonadIO m) => FunPtr C_ConfigMatchCallback -> MatchInfo -> Text -> Ptr () -> m Int32
genClosure_ConfigMatchCallback :: ConfigMatchCallback -> IO Closure
mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback)
noConfigMatchCallback :: Maybe ConfigMatchCallback
noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures
wrap_ConfigMatchCallback :: Maybe (Ptr (FunPtr C_ConfigMatchCallback)) -> ConfigMatchCallback_WithClosures -> C_ConfigMatchCallback
type C_CredAcquireCallback = CString -> CString -> Word32 -> Ptr Cred -> Ptr () -> IO Int32
type CredAcquireCallback = Text -> Maybe Text -> Word32 -> Cred -> IO Int32
type CredAcquireCallback_WithClosures = Text -> Maybe Text -> Word32 -> Cred -> Ptr () -> IO Int32
drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures
dynamic_CredAcquireCallback :: (HasCallStack, MonadIO m, IsCred a) => FunPtr C_CredAcquireCallback -> Text -> Maybe Text -> Word32 -> a -> Ptr () -> m Int32
genClosure_CredAcquireCallback :: CredAcquireCallback -> IO Closure
mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback)
noCredAcquireCallback :: Maybe CredAcquireCallback
noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures
wrap_CredAcquireCallback :: Maybe (Ptr (FunPtr C_CredAcquireCallback)) -> CredAcquireCallback_WithClosures -> C_CredAcquireCallback
type C_DiffBinaryCallback = Ptr DiffDelta -> Ptr DiffBinary -> Ptr () -> IO Int32
type DiffBinaryCallback = DiffDelta -> DiffBinary -> IO Int32
type DiffBinaryCallback_WithClosures = DiffDelta -> DiffBinary -> Ptr () -> IO Int32
drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures
dynamic_DiffBinaryCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffBinaryCallback -> DiffDelta -> DiffBinary -> Ptr () -> m Int32
genClosure_DiffBinaryCallback :: DiffBinaryCallback -> IO Closure
mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback)
noDiffBinaryCallback :: Maybe DiffBinaryCallback
noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures
wrap_DiffBinaryCallback :: Maybe (Ptr (FunPtr C_DiffBinaryCallback)) -> DiffBinaryCallback_WithClosures -> C_DiffBinaryCallback
type C_DiffFileCallback = Ptr DiffDelta -> CFloat -> Ptr () -> IO Int32
type DiffFileCallback = DiffDelta -> Float -> IO Int32
type DiffFileCallback_WithClosures = DiffDelta -> Float -> Ptr () -> IO Int32
drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures
dynamic_DiffFileCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffFileCallback -> DiffDelta -> Float -> Ptr () -> m Int32
genClosure_DiffFileCallback :: DiffFileCallback -> IO Closure
mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback)
noDiffFileCallback :: Maybe DiffFileCallback
noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures
wrap_DiffFileCallback :: Maybe (Ptr (FunPtr C_DiffFileCallback)) -> DiffFileCallback_WithClosures -> C_DiffFileCallback
type C_DiffHunkCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr () -> IO Int32
type DiffHunkCallback = DiffDelta -> DiffHunk -> IO Int32
type DiffHunkCallback_WithClosures = DiffDelta -> DiffHunk -> Ptr () -> IO Int32
drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures
dynamic_DiffHunkCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffHunkCallback -> DiffDelta -> DiffHunk -> Ptr () -> m Int32
genClosure_DiffHunkCallback :: DiffHunkCallback -> IO Closure
mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback)
noDiffHunkCallback :: Maybe DiffHunkCallback
noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures
wrap_DiffHunkCallback :: Maybe (Ptr (FunPtr C_DiffHunkCallback)) -> DiffHunkCallback_WithClosures -> C_DiffHunkCallback
type C_DiffLineCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr DiffLine -> Ptr () -> IO Int32
type DiffLineCallback = DiffDelta -> Maybe DiffHunk -> DiffLine -> IO Int32
type DiffLineCallback_WithClosures = DiffDelta -> Maybe DiffHunk -> DiffLine -> Ptr () -> IO Int32
drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures
dynamic_DiffLineCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffLineCallback -> DiffDelta -> Maybe DiffHunk -> DiffLine -> Ptr () -> m Int32
genClosure_DiffLineCallback :: DiffLineCallback -> IO Closure
mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback)
noDiffLineCallback :: Maybe DiffLineCallback
noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures
wrap_DiffLineCallback :: Maybe (Ptr (FunPtr C_DiffLineCallback)) -> DiffLineCallback_WithClosures -> C_DiffLineCallback
type C_DiffSimilarityMetricBufferSignatureCallback = Ptr DiffFile -> CString -> Word32 -> Ptr () -> Ptr () -> IO Int32
type DiffSimilarityMetricBufferSignatureCallback = DiffFile -> Text -> Word32 -> Ptr () -> IO Int32
type DiffSimilarityMetricBufferSignatureCallback_WithClosures = DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> IO Int32
drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures
dynamic_DiffSimilarityMetricBufferSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricBufferSignatureCallback -> DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> m Int32
genClosure_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> IO Closure
mk_DiffSimilarityMetricBufferSignatureCallback :: C_DiffSimilarityMetricBufferSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)
noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback
noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures
wrap_DiffSimilarityMetricBufferSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)) -> DiffSimilarityMetricBufferSignatureCallback_WithClosures -> C_DiffSimilarityMetricBufferSignatureCallback
type C_DiffSimilarityMetricFileSignatureCallback = Ptr DiffFile -> CString -> Ptr () -> Ptr () -> IO Int32
type DiffSimilarityMetricFileSignatureCallback = DiffFile -> Text -> Ptr () -> IO Int32
type DiffSimilarityMetricFileSignatureCallback_WithClosures = DiffFile -> Text -> Ptr () -> Ptr () -> IO Int32
drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures
dynamic_DiffSimilarityMetricFileSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFileSignatureCallback -> DiffFile -> Text -> Ptr () -> Ptr () -> m Int32
genClosure_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> IO Closure
mk_DiffSimilarityMetricFileSignatureCallback :: C_DiffSimilarityMetricFileSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)
noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback
noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures
wrap_DiffSimilarityMetricFileSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback)) -> DiffSimilarityMetricFileSignatureCallback_WithClosures -> C_DiffSimilarityMetricFileSignatureCallback
type C_DiffSimilarityMetricFreeSignatureCallback = Ptr () -> Ptr () -> IO ()
type DiffSimilarityMetricFreeSignatureCallback = Ptr () -> IO ()
type DiffSimilarityMetricFreeSignatureCallback_WithClosures = Ptr () -> Ptr () -> IO ()
drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures
dynamic_DiffSimilarityMetricFreeSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFreeSignatureCallback -> Ptr () -> Ptr () -> m ()
genClosure_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> IO Closure
mk_DiffSimilarityMetricFreeSignatureCallback :: C_DiffSimilarityMetricFreeSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)
noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback
noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures
wrap_DiffSimilarityMetricFreeSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)) -> DiffSimilarityMetricFreeSignatureCallback_WithClosures -> C_DiffSimilarityMetricFreeSignatureCallback
type C_DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32
type DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> IO Int32
type DiffSimilarityMetricSimilarityCallback_WithClosures = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32
drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures
dynamic_DiffSimilarityMetricSimilarityCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricSimilarityCallback -> Int32 -> Ptr () -> Ptr () -> Ptr () -> m Int32
genClosure_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> IO Closure
mk_DiffSimilarityMetricSimilarityCallback :: C_DiffSimilarityMetricSimilarityCallback -> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)
noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback
noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures
wrap_DiffSimilarityMetricSimilarityCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback)) -> DiffSimilarityMetricSimilarityCallback_WithClosures -> C_DiffSimilarityMetricSimilarityCallback
type C_NoteCallback = Ptr OId -> Ptr OId -> Ptr () -> IO Int32
type NoteCallback = OId -> OId -> IO Int32
type NoteCallback_WithClosures = OId -> OId -> Ptr () -> IO Int32
drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures
dynamic_NoteCallback :: (HasCallStack, MonadIO m) => FunPtr C_NoteCallback -> OId -> OId -> Ptr () -> m Int32
genClosure_NoteCallback :: NoteCallback -> IO Closure
mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback)
noNoteCallback :: Maybe NoteCallback
noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures
wrap_NoteCallback :: Maybe (Ptr (FunPtr C_NoteCallback)) -> NoteCallback_WithClosures -> C_NoteCallback
type C_ReferencesCallback = Ptr Ref -> Ptr () -> IO Int32
type ReferencesCallback = Ref -> IO Int32
type ReferencesCallback_WithClosures = Ref -> Ptr () -> IO Int32
drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures
dynamic_ReferencesCallback :: (HasCallStack, MonadIO m, IsRef a) => FunPtr C_ReferencesCallback -> a -> Ptr () -> m Int32
genClosure_ReferencesCallback :: ReferencesCallback -> IO Closure
mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback)
noReferencesCallback :: Maybe ReferencesCallback
noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures
wrap_ReferencesCallback :: Maybe (Ptr (FunPtr C_ReferencesCallback)) -> ReferencesCallback_WithClosures -> C_ReferencesCallback
type C_ReferencesNameCallback = CString -> Ptr () -> IO Int32
type ReferencesNameCallback = Text -> IO Int32
type ReferencesNameCallback_WithClosures = Text -> Ptr () -> IO Int32
drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures
dynamic_ReferencesNameCallback :: (HasCallStack, MonadIO m) => FunPtr C_ReferencesNameCallback -> Text -> Ptr () -> m Int32
genClosure_ReferencesNameCallback :: ReferencesNameCallback -> IO Closure
mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback)
noReferencesNameCallback :: Maybe ReferencesNameCallback
noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures
wrap_ReferencesNameCallback :: Maybe (Ptr (FunPtr C_ReferencesNameCallback)) -> ReferencesNameCallback_WithClosures -> C_ReferencesNameCallback
type C_RemoteListCallback = CString -> Ptr OId -> Ptr OId -> CInt -> Ptr () -> IO Int32
type RemoteListCallback = Text -> OId -> OId -> Bool -> IO Int32
type RemoteListCallback_WithClosures = Text -> OId -> OId -> Bool -> Ptr () -> IO Int32
drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures
dynamic_RemoteListCallback :: (HasCallStack, MonadIO m) => FunPtr C_RemoteListCallback -> Text -> OId -> OId -> Bool -> Ptr () -> m Int32
genClosure_RemoteListCallback :: RemoteListCallback -> IO Closure
mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback)
noRemoteListCallback :: Maybe RemoteListCallback
noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures
wrap_RemoteListCallback :: Maybe (Ptr (FunPtr C_RemoteListCallback)) -> RemoteListCallback_WithClosures -> C_RemoteListCallback
type C_StashCallback = Word32 -> CString -> Ptr OId -> Ptr () -> IO Int32
type StashCallback = Word32 -> Text -> OId -> IO Int32
type StashCallback_WithClosures = Word32 -> Text -> OId -> Ptr () -> IO Int32
drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures
dynamic_StashCallback :: (HasCallStack, MonadIO m) => FunPtr C_StashCallback -> Word32 -> Text -> OId -> Ptr () -> m Int32
genClosure_StashCallback :: StashCallback -> IO Closure
mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback)
noStashCallback :: Maybe StashCallback
noStashCallback_WithClosures :: Maybe StashCallback_WithClosures
wrap_StashCallback :: Maybe (Ptr (FunPtr C_StashCallback)) -> StashCallback_WithClosures -> C_StashCallback
type C_StatusCallback = CString -> CUInt -> Ptr () -> IO Int32
type StatusCallback = Text -> [StatusFlags] -> IO Int32
type StatusCallback_WithClosures = Text -> [StatusFlags] -> Ptr () -> IO Int32
drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures
dynamic_StatusCallback :: (HasCallStack, MonadIO m) => FunPtr C_StatusCallback -> Text -> [StatusFlags] -> Ptr () -> m Int32
genClosure_StatusCallback :: StatusCallback -> IO Closure
mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback)
noStatusCallback :: Maybe StatusCallback
noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures
wrap_StatusCallback :: Maybe (Ptr (FunPtr C_StatusCallback)) -> StatusCallback_WithClosures -> C_StatusCallback
type C_SubmoduleCallback = Ptr Submodule -> CString -> Ptr () -> IO Int32
type SubmoduleCallback = Submodule -> Text -> IO Int32
type SubmoduleCallback_WithClosures = Submodule -> Text -> Ptr () -> IO Int32
drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures
dynamic_SubmoduleCallback :: (HasCallStack, MonadIO m) => FunPtr C_SubmoduleCallback -> Submodule -> Text -> Ptr () -> m Int32
genClosure_SubmoduleCallback :: SubmoduleCallback -> IO Closure
mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback)
noSubmoduleCallback :: Maybe SubmoduleCallback
noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures
wrap_SubmoduleCallback :: Maybe (Ptr (FunPtr C_SubmoduleCallback)) -> SubmoduleCallback_WithClosures -> C_SubmoduleCallback
type C_TagCallback = CString -> Ptr OId -> Ptr () -> IO Int32
type TagCallback = Text -> OId -> IO Int32
type TagCallback_WithClosures = Text -> OId -> Ptr () -> IO Int32
drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures
dynamic_TagCallback :: (HasCallStack, MonadIO m) => FunPtr C_TagCallback -> Text -> OId -> Ptr () -> m Int32
genClosure_TagCallback :: TagCallback -> IO Closure
mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback)
noTagCallback :: Maybe TagCallback
noTagCallback_WithClosures :: Maybe TagCallback_WithClosures
wrap_TagCallback :: Maybe (Ptr (FunPtr C_TagCallback)) -> TagCallback_WithClosures -> C_TagCallback
type C_TransferProgressCallback = Ptr TransferProgress -> Ptr () -> IO Int32
type TransferProgressCallback = TransferProgress -> IO Int32
type TransferProgressCallback_WithClosures = TransferProgress -> Ptr () -> IO Int32
drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures
dynamic_TransferProgressCallback :: (HasCallStack, MonadIO m) => FunPtr C_TransferProgressCallback -> TransferProgress -> Ptr () -> m Int32
genClosure_TransferProgressCallback :: TransferProgressCallback -> IO Closure
mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback)
noTransferProgressCallback :: Maybe TransferProgressCallback
noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures
wrap_TransferProgressCallback :: Maybe (Ptr (FunPtr C_TransferProgressCallback)) -> TransferProgressCallback_WithClosures -> C_TransferProgressCallback
type C_TreeWalkCallback = CString -> Ptr TreeEntry -> Ptr () -> IO Int32
type TreeWalkCallback = Text -> TreeEntry -> IO Int32
type TreeWalkCallback_WithClosures = Text -> TreeEntry -> Ptr () -> IO Int32
drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures
dynamic_TreeWalkCallback :: (HasCallStack, MonadIO m) => FunPtr C_TreeWalkCallback -> Text -> TreeEntry -> Ptr () -> m Int32
genClosure_TreeWalkCallback :: TreeWalkCallback -> IO Closure
mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback)
noTreeWalkCallback :: Maybe TreeWalkCallback
noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures
wrap_TreeWalkCallback :: Maybe (Ptr (FunPtr C_TreeWalkCallback)) -> TreeWalkCallback_WithClosures -> C_TreeWalkCallback

Signals

ConfigCallback

type C_ConfigCallback = Ptr ConfigEntry -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type ConfigCallback Source #

Arguments

= ConfigEntry	`entry`: a `ConfigEntry`.
-> IO Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

The type of the callback functions for retrieving values from a Config. See configForeach.

type ConfigCallback_WithClosures Source #

Arguments

= ConfigEntry	`entry`: a `ConfigEntry`.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

The type of the callback functions for retrieving values from a Config. See configForeach.

drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ConfigCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ConfigCallback
-> ConfigEntry	`entry`: a `ConfigEntry`.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ConfigCallback :: ConfigCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback) Source #

Generate a function pointer callable from C code, from a C_ConfigCallback.

noConfigCallback :: Maybe ConfigCallback Source #

A convenience synonym for Nothing :: Maybe ConfigCallback.

noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ConfigCallback_WithClosures.

wrap_ConfigCallback :: Maybe (Ptr (FunPtr C_ConfigCallback)) -> ConfigCallback_WithClosures -> C_ConfigCallback Source #

Wrap a ConfigCallback into a C_ConfigCallback.

ConfigMatchCallback

type C_ConfigMatchCallback = Ptr MatchInfo -> CString -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type ConfigMatchCallback Source #

Arguments

= MatchInfo	`matchInfo`: the match
-> Text	`value`: the value
-> IO Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

The type of the callback functions for retrieving values from a Config using a regular expression. See configMatchForeach.

type ConfigMatchCallback_WithClosures Source #

Arguments

= MatchInfo	`matchInfo`: the match
-> Text	`value`: the value
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

The type of the callback functions for retrieving values from a Config using a regular expression. See configMatchForeach.

drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ConfigMatchCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ConfigMatchCallback
-> MatchInfo	`matchInfo`: the match
-> Text	`value`: the value
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next config value or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ConfigMatchCallback :: ConfigMatchCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback) Source #

Generate a function pointer callable from C code, from a C_ConfigMatchCallback.

noConfigMatchCallback :: Maybe ConfigMatchCallback Source #

A convenience synonym for Nothing :: Maybe ConfigMatchCallback.

noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ConfigMatchCallback_WithClosures.

wrap_ConfigMatchCallback :: Maybe (Ptr (FunPtr C_ConfigMatchCallback)) -> ConfigMatchCallback_WithClosures -> C_ConfigMatchCallback Source #

Wrap a ConfigMatchCallback into a C_ConfigMatchCallback.

CredAcquireCallback

type C_CredAcquireCallback = CString -> CString -> Word32 -> Ptr Cred -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type CredAcquireCallback Source #

Arguments

= Text	`url`: the resource for which we are demanding a credential.
-> Maybe Text	`usernameFromUrl`: The username that was embedded in a "user`host`" remote url, or NULL if not included.
-> Word32	`allowedTypes`: a bitmask stating which cred types are OK to return.
-> Cred	`cred`: newly created credential object.
-> IO Int32

Signature of a function which acquires a credential object.

type CredAcquireCallback_WithClosures Source #

Arguments

= Text	`url`: the resource for which we are demanding a credential.
-> Maybe Text	`usernameFromUrl`: The username that was embedded in a "user`host`" remote url, or NULL if not included.
-> Word32	`allowedTypes`: a bitmask stating which cred types are OK to return.
-> Cred	`cred`: newly created credential object.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32

Signature of a function which acquires a credential object.

drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CredAcquireCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsCred a)
=> FunPtr C_CredAcquireCallback
-> Text	`url`: the resource for which we are demanding a credential.
-> Maybe Text	`usernameFromUrl`: The username that was embedded in a "user`host`" remote url, or NULL if not included.
-> Word32	`allowedTypes`: a bitmask stating which cred types are OK to return.
-> a	`cred`: newly created credential object.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CredAcquireCallback :: CredAcquireCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback) Source #

Generate a function pointer callable from C code, from a C_CredAcquireCallback.

noCredAcquireCallback :: Maybe CredAcquireCallback Source #

A convenience synonym for Nothing :: Maybe CredAcquireCallback.

noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe CredAcquireCallback_WithClosures.

wrap_CredAcquireCallback :: Maybe (Ptr (FunPtr C_CredAcquireCallback)) -> CredAcquireCallback_WithClosures -> C_CredAcquireCallback Source #

Wrap a CredAcquireCallback into a C_CredAcquireCallback.

DiffBinaryCallback

type C_DiffBinaryCallback = Ptr DiffDelta -> Ptr DiffBinary -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffBinaryCallback Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> DiffBinary	`binary`: a `DiffBinary`.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each file.

type DiffBinaryCallback_WithClosures Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> DiffBinary	`binary`: a `DiffBinary`.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each file.

drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffBinaryCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_DiffBinaryCallback
-> DiffDelta	`delta`: a `DiffDelta`.
-> DiffBinary	`binary`: a `DiffBinary`.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffBinaryCallback :: DiffBinaryCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback) Source #

Generate a function pointer callable from C code, from a C_DiffBinaryCallback.

noDiffBinaryCallback :: Maybe DiffBinaryCallback Source #

A convenience synonym for Nothing :: Maybe DiffBinaryCallback.

noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DiffBinaryCallback_WithClosures.

wrap_DiffBinaryCallback :: Maybe (Ptr (FunPtr C_DiffBinaryCallback)) -> DiffBinaryCallback_WithClosures -> C_DiffBinaryCallback Source #

Wrap a DiffBinaryCallback into a C_DiffBinaryCallback.

DiffFileCallback

type C_DiffFileCallback = Ptr DiffDelta -> CFloat -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffFileCallback Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> Float	`progress`: the progress.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each file.

type DiffFileCallback_WithClosures Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> Float	`progress`: the progress.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each file.

drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffFileCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_DiffFileCallback
-> DiffDelta	`delta`: a `DiffDelta`.
-> Float	`progress`: the progress.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffFileCallback :: DiffFileCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback) Source #

Generate a function pointer callable from C code, from a C_DiffFileCallback.

noDiffFileCallback :: Maybe DiffFileCallback Source #

A convenience synonym for Nothing :: Maybe DiffFileCallback.

noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DiffFileCallback_WithClosures.

wrap_DiffFileCallback :: Maybe (Ptr (FunPtr C_DiffFileCallback)) -> DiffFileCallback_WithClosures -> C_DiffFileCallback Source #

Wrap a DiffFileCallback into a C_DiffFileCallback.

DiffHunkCallback

type C_DiffHunkCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffHunkCallback Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> DiffHunk	`hunk`: a `DiffHunk`.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each hunk.

type DiffHunkCallback_WithClosures Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> DiffHunk	`hunk`: a `DiffHunk`.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each hunk.

drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffHunkCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_DiffHunkCallback
-> DiffDelta	`delta`: a `DiffDelta`.
-> DiffHunk	`hunk`: a `DiffHunk`.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffHunkCallback :: DiffHunkCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback) Source #

Generate a function pointer callable from C code, from a C_DiffHunkCallback.

noDiffHunkCallback :: Maybe DiffHunkCallback Source #

A convenience synonym for Nothing :: Maybe DiffHunkCallback.

noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DiffHunkCallback_WithClosures.

wrap_DiffHunkCallback :: Maybe (Ptr (FunPtr C_DiffHunkCallback)) -> DiffHunkCallback_WithClosures -> C_DiffHunkCallback Source #

Wrap a DiffHunkCallback into a C_DiffHunkCallback.

DiffLineCallback

type C_DiffLineCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr DiffLine -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffLineCallback Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> Maybe DiffHunk	`hunk`: a `DiffHunk`.
-> DiffLine	`line`: a `DiffLine`.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each line.

type DiffLineCallback_WithClosures Source #

Arguments

= DiffDelta	`delta`: a `DiffDelta`.
-> Maybe DiffHunk	`hunk`: a `DiffHunk`.
-> DiffLine	`line`: a `DiffLine`.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Called for each line.

drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffLineCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_DiffLineCallback
-> DiffDelta	`delta`: a `DiffDelta`.
-> Maybe DiffHunk	`hunk`: a `DiffHunk`.
-> DiffLine	`line`: a `DiffLine`.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffLineCallback :: DiffLineCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback) Source #

Generate a function pointer callable from C code, from a C_DiffLineCallback.

noDiffLineCallback :: Maybe DiffLineCallback Source #

A convenience synonym for Nothing :: Maybe DiffLineCallback.

noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DiffLineCallback_WithClosures.

wrap_DiffLineCallback :: Maybe (Ptr (FunPtr C_DiffLineCallback)) -> DiffLineCallback_WithClosures -> C_DiffLineCallback Source #

Wrap a DiffLineCallback into a C_DiffLineCallback.

DiffSimilarityMetricBufferSignatureCallback

type C_DiffSimilarityMetricBufferSignatureCallback = Ptr DiffFile -> CString -> Word32 -> Ptr () -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffSimilarityMetricBufferSignatureCallback = DiffFile -> Text -> Word32 -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

type DiffSimilarityMetricBufferSignatureCallback_WithClosures = DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffSimilarityMetricBufferSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricBufferSignatureCallback -> DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> m Int32 Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> IO Closure Source #

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_DiffSimilarityMetricBufferSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricBufferSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures.

DiffSimilarityMetricFileSignatureCallback

type C_DiffSimilarityMetricFileSignatureCallback = Ptr DiffFile -> CString -> Ptr () -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffSimilarityMetricFileSignatureCallback = DiffFile -> Text -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

type DiffSimilarityMetricFileSignatureCallback_WithClosures = DiffFile -> Text -> Ptr () -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffSimilarityMetricFileSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFileSignatureCallback -> DiffFile -> Text -> Ptr () -> Ptr () -> m Int32 Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> IO Closure Source #

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_DiffSimilarityMetricFileSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFileSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures.

DiffSimilarityMetricFreeSignatureCallback

type C_DiffSimilarityMetricFreeSignatureCallback = Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type DiffSimilarityMetricFreeSignatureCallback = Ptr () -> IO () Source #

No description available in the introspection data.

type DiffSimilarityMetricFreeSignatureCallback_WithClosures = Ptr () -> Ptr () -> IO () Source #

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffSimilarityMetricFreeSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFreeSignatureCallback -> Ptr () -> Ptr () -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> IO Closure Source #

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_DiffSimilarityMetricFreeSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFreeSignatureCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures.

DiffSimilarityMetricSimilarityCallback

type C_DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

type DiffSimilarityMetricSimilarityCallback_WithClosures = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32 Source #

No description available in the introspection data.

drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DiffSimilarityMetricSimilarityCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricSimilarityCallback -> Int32 -> Ptr () -> Ptr () -> Ptr () -> m Int32 Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> IO Closure Source #

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_DiffSimilarityMetricSimilarityCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricSimilarityCallback.

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures.

NoteCallback

type C_NoteCallback = Ptr OId -> Ptr OId -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type NoteCallback Source #

Arguments

= OId	`blobId`: id of the blob containing the message.
-> OId	`annotatedObjectId`: id of the git object being annotated.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the notes, callback that will be issued per note. See repositoryNoteForeach.

type NoteCallback_WithClosures Source #

Arguments

= OId	`blobId`: id of the blob containing the message.
-> OId	`annotatedObjectId`: id of the git object being annotated.
-> Ptr ()	`userData`: user-suplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the notes, callback that will be issued per note. See repositoryNoteForeach.

drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_NoteCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_NoteCallback
-> OId	`blobId`: id of the blob containing the message.
-> OId	`annotatedObjectId`: id of the git object being annotated.
-> Ptr ()	`userData`: user-suplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_NoteCallback :: NoteCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback) Source #

Generate a function pointer callable from C code, from a C_NoteCallback.

noNoteCallback :: Maybe NoteCallback Source #

A convenience synonym for Nothing :: Maybe NoteCallback.

noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe NoteCallback_WithClosures.

wrap_NoteCallback :: Maybe (Ptr (FunPtr C_NoteCallback)) -> NoteCallback_WithClosures -> C_NoteCallback Source #

Wrap a NoteCallback into a C_NoteCallback.

ReferencesCallback

type C_ReferencesCallback = Ptr Ref -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type ReferencesCallback Source #

Arguments

= Ref	`reference`: the reference.
-> IO Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

The type of the callback functions for retrieving the references in a Repository. See repositoryReferencesForeach.

type ReferencesCallback_WithClosures Source #

Arguments

= Ref	`reference`: the reference.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

The type of the callback functions for retrieving the references in a Repository. See repositoryReferencesForeach.

drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ReferencesCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsRef a)
=> FunPtr C_ReferencesCallback
-> a	`reference`: the reference.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ReferencesCallback :: ReferencesCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback) Source #

Generate a function pointer callable from C code, from a C_ReferencesCallback.

noReferencesCallback :: Maybe ReferencesCallback Source #

A convenience synonym for Nothing :: Maybe ReferencesCallback.

noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ReferencesCallback_WithClosures.

wrap_ReferencesCallback :: Maybe (Ptr (FunPtr C_ReferencesCallback)) -> ReferencesCallback_WithClosures -> C_ReferencesCallback Source #

Wrap a ReferencesCallback into a C_ReferencesCallback.

ReferencesNameCallback

type C_ReferencesNameCallback = CString -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type ReferencesNameCallback Source #

Arguments

= Text	`name`: the name of the reference
-> IO Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

The type of the callback functions for retrieving the references in a Repository. See repositoryReferencesForeachName.

type ReferencesNameCallback_WithClosures Source #

Arguments

= Text	`name`: the name of the reference
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

The type of the callback functions for retrieving the references in a Repository. See repositoryReferencesForeachName.

drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ReferencesNameCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ReferencesNameCallback
-> Text	`name`: the name of the reference
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next references or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ReferencesNameCallback :: ReferencesNameCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback) Source #

Generate a function pointer callable from C code, from a C_ReferencesNameCallback.

noReferencesNameCallback :: Maybe ReferencesNameCallback Source #

A convenience synonym for Nothing :: Maybe ReferencesNameCallback.

noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ReferencesNameCallback_WithClosures.

wrap_ReferencesNameCallback :: Maybe (Ptr (FunPtr C_ReferencesNameCallback)) -> ReferencesNameCallback_WithClosures -> C_ReferencesNameCallback Source #

Wrap a ReferencesNameCallback into a C_ReferencesNameCallback.

RemoteListCallback

type C_RemoteListCallback = CString -> Ptr OId -> Ptr OId -> CInt -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type RemoteListCallback Source #

Arguments

= Text	`name`: the name of the reference.
-> OId	`oid`: the reference's oid.
-> OId	`loid`: the reference's loid.
-> Bool	`local`: if available locally.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

The type of the callback functions for listing the references of a Remote. See remoteList.

type RemoteListCallback_WithClosures Source #

Arguments

= Text	`name`: the name of the reference.
-> OId	`oid`: the reference's oid.
-> OId	`loid`: the reference's loid.
-> Bool	`local`: if available locally.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

The type of the callback functions for listing the references of a Remote. See remoteList.

drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_RemoteListCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_RemoteListCallback
-> Text	`name`: the name of the reference.
-> OId	`oid`: the reference's oid.
-> OId	`loid`: the reference's loid.
-> Bool	`local`: if available locally.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_RemoteListCallback :: RemoteListCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback) Source #

Generate a function pointer callable from C code, from a C_RemoteListCallback.

noRemoteListCallback :: Maybe RemoteListCallback Source #

A convenience synonym for Nothing :: Maybe RemoteListCallback.

noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe RemoteListCallback_WithClosures.

wrap_RemoteListCallback :: Maybe (Ptr (FunPtr C_RemoteListCallback)) -> RemoteListCallback_WithClosures -> C_RemoteListCallback Source #

Wrap a RemoteListCallback into a C_RemoteListCallback.

StashCallback

type C_StashCallback = Word32 -> CString -> Ptr OId -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type StashCallback Source #

Arguments

= Word32	`index`: the position within the stash list. 0 points to the most recent stashed state.
-> Text	`message`: the stash message.
-> OId	`stashOid`: the commit oid of the stashed state.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the stashed states, callback that will be issued per entry. See repositoryStashForeach.

type StashCallback_WithClosures Source #

Arguments

= Word32	`index`: the position within the stash list. 0 points to the most recent stashed state.
-> Text	`message`: the stash message.
-> OId	`stashOid`: the commit oid of the stashed state.
-> Ptr ()	`userData`: user-suplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the stashed states, callback that will be issued per entry. See repositoryStashForeach.

drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_StashCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_StashCallback
-> Word32	`index`: the position within the stash list. 0 points to the most recent stashed state.
-> Text	`message`: the stash message.
-> OId	`stashOid`: the commit oid of the stashed state.
-> Ptr ()	`userData`: user-suplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StashCallback :: StashCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback) Source #

Generate a function pointer callable from C code, from a C_StashCallback.

noStashCallback :: Maybe StashCallback Source #

A convenience synonym for Nothing :: Maybe StashCallback.

noStashCallback_WithClosures :: Maybe StashCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe StashCallback_WithClosures.

wrap_StashCallback :: Maybe (Ptr (FunPtr C_StashCallback)) -> StashCallback_WithClosures -> C_StashCallback Source #

Wrap a StashCallback into a C_StashCallback.

StatusCallback

type C_StatusCallback = CString -> CUInt -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type StatusCallback Source #

Arguments

= Text	`path`: the file to retrieve status for, rooted at the repository working dir.
-> [StatusFlags]	`statusFlags`: the status value.
-> IO Int32	Returns: 0 to go for the next file or a `Error` in case there was an error.

The type of the callback functions for retrieving the status of the files in a Repository. See repositoryFileStatusForeach.

type StatusCallback_WithClosures Source #

Arguments

= Text	`path`: the file to retrieve status for, rooted at the repository working dir.
-> [StatusFlags]	`statusFlags`: the status value.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next file or a `Error` in case there was an error.

The type of the callback functions for retrieving the status of the files in a Repository. See repositoryFileStatusForeach.

drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_StatusCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_StatusCallback
-> Text	`path`: the file to retrieve status for, rooted at the repository working dir.
-> [StatusFlags]	`statusFlags`: the status value.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next file or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StatusCallback :: StatusCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback) Source #

Generate a function pointer callable from C code, from a C_StatusCallback.

noStatusCallback :: Maybe StatusCallback Source #

A convenience synonym for Nothing :: Maybe StatusCallback.

noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe StatusCallback_WithClosures.

wrap_StatusCallback :: Maybe (Ptr (FunPtr C_StatusCallback)) -> StatusCallback_WithClosures -> C_StatusCallback Source #

Wrap a StatusCallback into a C_StatusCallback.

SubmoduleCallback

type C_SubmoduleCallback = Ptr Submodule -> CString -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type SubmoduleCallback Source #

Arguments

= Submodule	`submodule`: a `Submodule`.
-> Text	`name`: the name of the submodule.
-> IO Int32	Returns: 0 to go for the next submodule or a `Error` in case there was an error.

The type of the callback functions for retrieving the submodules in a Repository. See repositorySubmoduleForeach.

type SubmoduleCallback_WithClosures Source #

Arguments

= Submodule	`submodule`: a `Submodule`.
-> Text	`name`: the name of the submodule.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next submodule or a `Error` in case there was an error.

The type of the callback functions for retrieving the submodules in a Repository. See repositorySubmoduleForeach.

drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SubmoduleCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_SubmoduleCallback
-> Submodule	`submodule`: a `Submodule`.
-> Text	`name`: the name of the submodule.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next submodule or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SubmoduleCallback :: SubmoduleCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback) Source #

Generate a function pointer callable from C code, from a C_SubmoduleCallback.

noSubmoduleCallback :: Maybe SubmoduleCallback Source #

A convenience synonym for Nothing :: Maybe SubmoduleCallback.

noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe SubmoduleCallback_WithClosures.

wrap_SubmoduleCallback :: Maybe (Ptr (FunPtr C_SubmoduleCallback)) -> SubmoduleCallback_WithClosures -> C_SubmoduleCallback Source #

Wrap a SubmoduleCallback into a C_SubmoduleCallback.

TagCallback

type C_TagCallback = CString -> Ptr OId -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type TagCallback Source #

Arguments

= Text	`name`: the tag name.
-> OId	`tagOid`: the tag oid.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the tags, callback that will be issued per entry. See repositoryTagForeach.

type TagCallback_WithClosures Source #

Arguments

= Text	`name`: the tag name.
-> OId	`tagOid`: the tag oid.
-> Ptr ()	`userData`: user-suplied data.
-> IO Int32	Returns: 0 to go continue or a `Error` in case there was an error.

When iterating over all the tags, callback that will be issued per entry. See repositoryTagForeach.

drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TagCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TagCallback
-> Text	`name`: the tag name.
-> OId	`tagOid`: the tag oid.
-> Ptr ()	`userData`: user-suplied data.
-> m Int32	Returns: 0 to go continue or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TagCallback :: TagCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback) Source #

Generate a function pointer callable from C code, from a C_TagCallback.

noTagCallback :: Maybe TagCallback Source #

A convenience synonym for Nothing :: Maybe TagCallback.

noTagCallback_WithClosures :: Maybe TagCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe TagCallback_WithClosures.

wrap_TagCallback :: Maybe (Ptr (FunPtr C_TagCallback)) -> TagCallback_WithClosures -> C_TagCallback Source #

Wrap a TagCallback into a C_TagCallback.

TransferProgressCallback

type C_TransferProgressCallback = Ptr TransferProgress -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type TransferProgressCallback Source #

Arguments

= TransferProgress	`stats`: a `TransferProgress`.
-> IO Int32	Returns: a value less than zero to cancel the transfer.

Progress callbacks during indexing.

type TransferProgressCallback_WithClosures Source #

Arguments

= TransferProgress	`stats`: a `TransferProgress`.
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: a value less than zero to cancel the transfer.

Progress callbacks during indexing.

drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TransferProgressCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TransferProgressCallback
-> TransferProgress	`stats`: a `TransferProgress`.
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: a value less than zero to cancel the transfer.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TransferProgressCallback :: TransferProgressCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback) Source #

Generate a function pointer callable from C code, from a C_TransferProgressCallback.

noTransferProgressCallback :: Maybe TransferProgressCallback Source #

A convenience synonym for Nothing :: Maybe TransferProgressCallback.

noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe TransferProgressCallback_WithClosures.

wrap_TransferProgressCallback :: Maybe (Ptr (FunPtr C_TransferProgressCallback)) -> TransferProgressCallback_WithClosures -> C_TransferProgressCallback Source #

Wrap a TransferProgressCallback into a C_TransferProgressCallback.

TreeWalkCallback

type C_TreeWalkCallback = CString -> Ptr TreeEntry -> Ptr () -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type TreeWalkCallback Source #

Arguments

= Text	`root`: the current (relative) root of the entry
-> TreeEntry	`entry`: the tree entry
-> IO Int32	Returns: 0 to go for the next entry or a `Error` in case there was an error.

The type of the callback functions for walking a tree. See treeWalk.

type TreeWalkCallback_WithClosures Source #

Arguments

= Text	`root`: the current (relative) root of the entry
-> TreeEntry	`entry`: the tree entry
-> Ptr ()	`userData`: user-supplied data.
-> IO Int32	Returns: 0 to go for the next entry or a `Error` in case there was an error.

The type of the callback functions for walking a tree. See treeWalk.

drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeWalkCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TreeWalkCallback
-> Text	`root`: the current (relative) root of the entry
-> TreeEntry	`entry`: the tree entry
-> Ptr ()	`userData`: user-supplied data.
-> m Int32	Returns: 0 to go for the next entry or a `Error` in case there was an error.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TreeWalkCallback :: TreeWalkCallback -> IO Closure Source #

Wrap the callback into a Closure.

mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback) Source #

Generate a function pointer callable from C code, from a C_TreeWalkCallback.

noTreeWalkCallback :: Maybe TreeWalkCallback Source #

A convenience synonym for Nothing :: Maybe TreeWalkCallback.

noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeWalkCallback_WithClosures.

wrap_TreeWalkCallback :: Maybe (Ptr (FunPtr C_TreeWalkCallback)) -> TreeWalkCallback_WithClosures -> C_TreeWalkCallback Source #

Wrap a TreeWalkCallback into a C_TreeWalkCallback.