GI.Ggit.Callbacks

Signals

ConfigCallback

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

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

type ConfigCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_ConfigCallback

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 :: MonadIO m => ConfigCallback -> m (GClosure C_ConfigCallback)

Wrap the callback into a GClosure.

mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback)

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

noConfigCallback :: Maybe ConfigCallback

A convenience synonym for Nothing :: Maybe ConfigCallback.

noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures

A convenience synonym for Nothing :: Maybe ConfigCallback_WithClosures.

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

Wrap a ConfigCallback into a C_ConfigCallback.

ConfigMatchCallback

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

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

type ConfigMatchCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_ConfigMatchCallback

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 :: MonadIO m => ConfigMatchCallback -> m (GClosure C_ConfigMatchCallback)

Wrap the callback into a GClosure.

mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback)

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

noConfigMatchCallback :: Maybe ConfigMatchCallback

A convenience synonym for Nothing :: Maybe ConfigMatchCallback.

noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures

A convenience synonym for Nothing :: Maybe ConfigMatchCallback_WithClosures.

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

Wrap a ConfigMatchCallback into a C_ConfigMatchCallback.

CredAcquireCallback

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

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

type CredAcquireCallback

Arguments

 = Text

url: the resource for which we are demanding a credential.

-> Maybe Text

usernameFromUrl: The username that was embedded in a "userhost" 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

Arguments

 = Text

url: the resource for which we are demanding a credential.

-> Maybe Text

usernameFromUrl: The username that was embedded in a "userhost" 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

A simple wrapper that ignores the closure arguments.

dynamic_CredAcquireCallback

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 "userhost" 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 :: MonadIO m => CredAcquireCallback -> m (GClosure C_CredAcquireCallback)

Wrap the callback into a GClosure.

mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback)

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

noCredAcquireCallback :: Maybe CredAcquireCallback

A convenience synonym for Nothing :: Maybe CredAcquireCallback.

noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures

A convenience synonym for Nothing :: Maybe CredAcquireCallback_WithClosures.

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

Wrap a CredAcquireCallback into a C_CredAcquireCallback.

DiffBinaryCallback

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

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

type DiffBinaryCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_DiffBinaryCallback

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 :: MonadIO m => DiffBinaryCallback -> m (GClosure C_DiffBinaryCallback)

Wrap the callback into a GClosure.

mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback)

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

noDiffBinaryCallback :: Maybe DiffBinaryCallback

A convenience synonym for Nothing :: Maybe DiffBinaryCallback.

noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffBinaryCallback_WithClosures.

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

Wrap a DiffBinaryCallback into a C_DiffBinaryCallback.

DiffFileCallback

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

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

type DiffFileCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_DiffFileCallback

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 :: MonadIO m => DiffFileCallback -> m (GClosure C_DiffFileCallback)

Wrap the callback into a GClosure.

mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback)

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

noDiffFileCallback :: Maybe DiffFileCallback

A convenience synonym for Nothing :: Maybe DiffFileCallback.

noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffFileCallback_WithClosures.

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

Wrap a DiffFileCallback into a C_DiffFileCallback.

DiffHunkCallback

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

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

type DiffHunkCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_DiffHunkCallback

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 :: MonadIO m => DiffHunkCallback -> m (GClosure C_DiffHunkCallback)

Wrap the callback into a GClosure.

mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback)

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

noDiffHunkCallback :: Maybe DiffHunkCallback

A convenience synonym for Nothing :: Maybe DiffHunkCallback.

noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffHunkCallback_WithClosures.

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

Wrap a DiffHunkCallback into a C_DiffHunkCallback.

DiffLineCallback

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

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

type DiffLineCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_DiffLineCallback

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 :: MonadIO m => DiffLineCallback -> m (GClosure C_DiffLineCallback)

Wrap the callback into a GClosure.

mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback)

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

noDiffLineCallback :: Maybe DiffLineCallback

A convenience synonym for Nothing :: Maybe DiffLineCallback.

noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffLineCallback_WithClosures.

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

Wrap a DiffLineCallback into a C_DiffLineCallback.

DiffSimilarityMetricBufferSignatureCallback

type C_DiffSimilarityMetricBufferSignatureCallback = Ptr DiffFile -> CString -> Word64 -> Ptr () -> Ptr () -> IO Int32

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

type DiffSimilarityMetricBufferSignatureCallback = DiffFile -> Text -> Word64 -> Ptr () -> IO Int32

No description available in the introspection data.

type DiffSimilarityMetricBufferSignatureCallback_WithClosures = DiffFile -> Text -> Word64 -> Ptr () -> Ptr () -> IO Int32

No description available in the introspection data.

drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures

A simple wrapper that ignores the closure arguments.

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

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

genClosure_DiffSimilarityMetricBufferSignatureCallback :: MonadIO m => DiffSimilarityMetricBufferSignatureCallback -> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)

Wrap the callback into a GClosure.

mk_DiffSimilarityMetricBufferSignatureCallback :: C_DiffSimilarityMetricBufferSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)

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

noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricBufferSignatureCallback.

noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures.

wrap_DiffSimilarityMetricBufferSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)) -> DiffSimilarityMetricBufferSignatureCallback_WithClosures -> C_DiffSimilarityMetricBufferSignatureCallback

Wrap a DiffSimilarityMetricBufferSignatureCallback into a C_DiffSimilarityMetricBufferSignatureCallback.

DiffSimilarityMetricFileSignatureCallback

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures

A simple wrapper that ignores the closure arguments.

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

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

genClosure_DiffSimilarityMetricFileSignatureCallback :: MonadIO m => DiffSimilarityMetricFileSignatureCallback -> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)

Wrap the callback into a GClosure.

mk_DiffSimilarityMetricFileSignatureCallback :: C_DiffSimilarityMetricFileSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)

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

noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFileSignatureCallback.

noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures.

wrap_DiffSimilarityMetricFileSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback)) -> DiffSimilarityMetricFileSignatureCallback_WithClosures -> C_DiffSimilarityMetricFileSignatureCallback

Wrap a DiffSimilarityMetricFileSignatureCallback into a C_DiffSimilarityMetricFileSignatureCallback.

DiffSimilarityMetricFreeSignatureCallback

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

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

type DiffSimilarityMetricFreeSignatureCallback = Ptr () -> IO ()

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures

A simple wrapper that ignores the closure arguments.

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

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

genClosure_DiffSimilarityMetricFreeSignatureCallback :: MonadIO m => DiffSimilarityMetricFreeSignatureCallback -> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)

Wrap the callback into a GClosure.

mk_DiffSimilarityMetricFreeSignatureCallback :: C_DiffSimilarityMetricFreeSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)

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

noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFreeSignatureCallback.

noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures.

wrap_DiffSimilarityMetricFreeSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)) -> DiffSimilarityMetricFreeSignatureCallback_WithClosures -> C_DiffSimilarityMetricFreeSignatureCallback

Wrap a DiffSimilarityMetricFreeSignatureCallback into a C_DiffSimilarityMetricFreeSignatureCallback.

DiffSimilarityMetricSimilarityCallback

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures

A simple wrapper that ignores the closure arguments.

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

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

genClosure_DiffSimilarityMetricSimilarityCallback :: MonadIO m => DiffSimilarityMetricSimilarityCallback -> m (GClosure C_DiffSimilarityMetricSimilarityCallback)

Wrap the callback into a GClosure.

mk_DiffSimilarityMetricSimilarityCallback :: C_DiffSimilarityMetricSimilarityCallback -> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)

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

noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricSimilarityCallback.

noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures

A convenience synonym for Nothing :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures.

wrap_DiffSimilarityMetricSimilarityCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback)) -> DiffSimilarityMetricSimilarityCallback_WithClosures -> C_DiffSimilarityMetricSimilarityCallback

Wrap a DiffSimilarityMetricSimilarityCallback into a C_DiffSimilarityMetricSimilarityCallback.

NoteCallback

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

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

type NoteCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_NoteCallback

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 :: MonadIO m => NoteCallback -> m (GClosure C_NoteCallback)

Wrap the callback into a GClosure.

mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback)

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

noNoteCallback :: Maybe NoteCallback

A convenience synonym for Nothing :: Maybe NoteCallback.

noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures

A convenience synonym for Nothing :: Maybe NoteCallback_WithClosures.

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

Wrap a NoteCallback into a C_NoteCallback.

ReferencesCallback

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

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

type ReferencesCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_ReferencesCallback

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 :: MonadIO m => ReferencesCallback -> m (GClosure C_ReferencesCallback)

Wrap the callback into a GClosure.

mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback)

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

noReferencesCallback :: Maybe ReferencesCallback

A convenience synonym for Nothing :: Maybe ReferencesCallback.

noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures

A convenience synonym for Nothing :: Maybe ReferencesCallback_WithClosures.

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

Wrap a ReferencesCallback into a C_ReferencesCallback.

ReferencesNameCallback

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

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

type ReferencesNameCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_ReferencesNameCallback

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 :: MonadIO m => ReferencesNameCallback -> m (GClosure C_ReferencesNameCallback)

Wrap the callback into a GClosure.

mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback)

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

noReferencesNameCallback :: Maybe ReferencesNameCallback

A convenience synonym for Nothing :: Maybe ReferencesNameCallback.

noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures

A convenience synonym for Nothing :: Maybe ReferencesNameCallback_WithClosures.

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

Wrap a ReferencesNameCallback into a C_ReferencesNameCallback.

RemoteListCallback

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

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

type RemoteListCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_RemoteListCallback

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 :: MonadIO m => RemoteListCallback -> m (GClosure C_RemoteListCallback)

Wrap the callback into a GClosure.

mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback)

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

noRemoteListCallback :: Maybe RemoteListCallback

A convenience synonym for Nothing :: Maybe RemoteListCallback.

noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures

A convenience synonym for Nothing :: Maybe RemoteListCallback_WithClosures.

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

Wrap a RemoteListCallback into a C_RemoteListCallback.

StashCallback

type C_StashCallback = Word64 -> CString -> Ptr OId -> Ptr () -> IO Int32

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

type StashCallback

Arguments

 = Word64

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

Arguments

 = Word64

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

A simple wrapper that ignores the closure arguments.

dynamic_StashCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StashCallback

-> Word64

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 :: MonadIO m => StashCallback -> m (GClosure C_StashCallback)

Wrap the callback into a GClosure.

mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback)

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

noStashCallback :: Maybe StashCallback

A convenience synonym for Nothing :: Maybe StashCallback.

noStashCallback_WithClosures :: Maybe StashCallback_WithClosures

A convenience synonym for Nothing :: Maybe StashCallback_WithClosures.

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

Wrap a StashCallback into a C_StashCallback.

StatusCallback

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

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

type StatusCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_StatusCallback

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 :: MonadIO m => StatusCallback -> m (GClosure C_StatusCallback)

Wrap the callback into a GClosure.

mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback)

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

noStatusCallback :: Maybe StatusCallback

A convenience synonym for Nothing :: Maybe StatusCallback.

noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures

A convenience synonym for Nothing :: Maybe StatusCallback_WithClosures.

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

Wrap a StatusCallback into a C_StatusCallback.

SubmoduleCallback

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

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

type SubmoduleCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_SubmoduleCallback

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 :: MonadIO m => SubmoduleCallback -> m (GClosure C_SubmoduleCallback)

Wrap the callback into a GClosure.

mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback)

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

noSubmoduleCallback :: Maybe SubmoduleCallback

A convenience synonym for Nothing :: Maybe SubmoduleCallback.

noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures

A convenience synonym for Nothing :: Maybe SubmoduleCallback_WithClosures.

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

Wrap a SubmoduleCallback into a C_SubmoduleCallback.

TagCallback

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

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

type TagCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_TagCallback

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 :: MonadIO m => TagCallback -> m (GClosure C_TagCallback)

Wrap the callback into a GClosure.

mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback)

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

noTagCallback :: Maybe TagCallback

A convenience synonym for Nothing :: Maybe TagCallback.

noTagCallback_WithClosures :: Maybe TagCallback_WithClosures

A convenience synonym for Nothing :: Maybe TagCallback_WithClosures.

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

Wrap a TagCallback into a C_TagCallback.

TransferProgressCallback

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

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

type TransferProgressCallback

Arguments

 = TransferProgress

stats: a TransferProgress.

-> IO Int32

Returns: a value less than zero to cancel the transfer.

Progress callbacks during indexing.

type TransferProgressCallback_WithClosures

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

A simple wrapper that ignores the closure arguments.

dynamic_TransferProgressCallback

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 :: MonadIO m => TransferProgressCallback -> m (GClosure C_TransferProgressCallback)

Wrap the callback into a GClosure.

mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback)

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

noTransferProgressCallback :: Maybe TransferProgressCallback

A convenience synonym for Nothing :: Maybe TransferProgressCallback.

noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures

A convenience synonym for Nothing :: Maybe TransferProgressCallback_WithClosures.

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

Wrap a TransferProgressCallback into a C_TransferProgressCallback.

TreeWalkCallback

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

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

type TreeWalkCallback

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

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeWalkCallback

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 :: MonadIO m => TreeWalkCallback -> m (GClosure C_TreeWalkCallback)

Wrap the callback into a GClosure.

mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback)

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

noTreeWalkCallback :: Maybe TreeWalkCallback

A convenience synonym for Nothing :: Maybe TreeWalkCallback.

noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures

A convenience synonym for Nothing :: Maybe TreeWalkCallback_WithClosures.

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

Wrap a TreeWalkCallback into a C_TreeWalkCallback.