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

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`.
-> 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`.
-> 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`.
-> 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 for the callback on the (unwrapped) C side.

No description available in the introspection data.

drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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 for the callback on the (unwrapped) C side.

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

No description available in the introspection data.

drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

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.