#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Callbacks
(
C_ConfigCallback ,
ConfigCallback ,
ConfigCallback_WithClosures ,
drop_closures_ConfigCallback ,
dynamic_ConfigCallback ,
genClosure_ConfigCallback ,
mk_ConfigCallback ,
noConfigCallback ,
noConfigCallback_WithClosures ,
wrap_ConfigCallback ,
C_ConfigMatchCallback ,
ConfigMatchCallback ,
ConfigMatchCallback_WithClosures ,
drop_closures_ConfigMatchCallback ,
dynamic_ConfigMatchCallback ,
genClosure_ConfigMatchCallback ,
mk_ConfigMatchCallback ,
noConfigMatchCallback ,
noConfigMatchCallback_WithClosures ,
wrap_ConfigMatchCallback ,
C_CredAcquireCallback ,
CredAcquireCallback ,
CredAcquireCallback_WithClosures ,
drop_closures_CredAcquireCallback ,
dynamic_CredAcquireCallback ,
genClosure_CredAcquireCallback ,
mk_CredAcquireCallback ,
noCredAcquireCallback ,
noCredAcquireCallback_WithClosures ,
wrap_CredAcquireCallback ,
C_DiffBinaryCallback ,
DiffBinaryCallback ,
DiffBinaryCallback_WithClosures ,
drop_closures_DiffBinaryCallback ,
dynamic_DiffBinaryCallback ,
genClosure_DiffBinaryCallback ,
mk_DiffBinaryCallback ,
noDiffBinaryCallback ,
noDiffBinaryCallback_WithClosures ,
wrap_DiffBinaryCallback ,
C_DiffFileCallback ,
DiffFileCallback ,
DiffFileCallback_WithClosures ,
drop_closures_DiffFileCallback ,
dynamic_DiffFileCallback ,
genClosure_DiffFileCallback ,
mk_DiffFileCallback ,
noDiffFileCallback ,
noDiffFileCallback_WithClosures ,
wrap_DiffFileCallback ,
C_DiffHunkCallback ,
DiffHunkCallback ,
DiffHunkCallback_WithClosures ,
drop_closures_DiffHunkCallback ,
dynamic_DiffHunkCallback ,
genClosure_DiffHunkCallback ,
mk_DiffHunkCallback ,
noDiffHunkCallback ,
noDiffHunkCallback_WithClosures ,
wrap_DiffHunkCallback ,
C_DiffLineCallback ,
DiffLineCallback ,
DiffLineCallback_WithClosures ,
drop_closures_DiffLineCallback ,
dynamic_DiffLineCallback ,
genClosure_DiffLineCallback ,
mk_DiffLineCallback ,
noDiffLineCallback ,
noDiffLineCallback_WithClosures ,
wrap_DiffLineCallback ,
C_DiffSimilarityMetricBufferSignatureCallback,
DiffSimilarityMetricBufferSignatureCallback,
DiffSimilarityMetricBufferSignatureCallback_WithClosures,
drop_closures_DiffSimilarityMetricBufferSignatureCallback,
dynamic_DiffSimilarityMetricBufferSignatureCallback,
genClosure_DiffSimilarityMetricBufferSignatureCallback,
mk_DiffSimilarityMetricBufferSignatureCallback,
noDiffSimilarityMetricBufferSignatureCallback,
noDiffSimilarityMetricBufferSignatureCallback_WithClosures,
wrap_DiffSimilarityMetricBufferSignatureCallback,
C_DiffSimilarityMetricFileSignatureCallback,
DiffSimilarityMetricFileSignatureCallback,
DiffSimilarityMetricFileSignatureCallback_WithClosures,
drop_closures_DiffSimilarityMetricFileSignatureCallback,
dynamic_DiffSimilarityMetricFileSignatureCallback,
genClosure_DiffSimilarityMetricFileSignatureCallback,
mk_DiffSimilarityMetricFileSignatureCallback,
noDiffSimilarityMetricFileSignatureCallback,
noDiffSimilarityMetricFileSignatureCallback_WithClosures,
wrap_DiffSimilarityMetricFileSignatureCallback,
C_DiffSimilarityMetricFreeSignatureCallback,
DiffSimilarityMetricFreeSignatureCallback,
DiffSimilarityMetricFreeSignatureCallback_WithClosures,
drop_closures_DiffSimilarityMetricFreeSignatureCallback,
dynamic_DiffSimilarityMetricFreeSignatureCallback,
genClosure_DiffSimilarityMetricFreeSignatureCallback,
mk_DiffSimilarityMetricFreeSignatureCallback,
noDiffSimilarityMetricFreeSignatureCallback,
noDiffSimilarityMetricFreeSignatureCallback_WithClosures,
wrap_DiffSimilarityMetricFreeSignatureCallback,
C_DiffSimilarityMetricSimilarityCallback,
DiffSimilarityMetricSimilarityCallback ,
DiffSimilarityMetricSimilarityCallback_WithClosures,
drop_closures_DiffSimilarityMetricSimilarityCallback,
dynamic_DiffSimilarityMetricSimilarityCallback,
genClosure_DiffSimilarityMetricSimilarityCallback,
mk_DiffSimilarityMetricSimilarityCallback,
noDiffSimilarityMetricSimilarityCallback,
noDiffSimilarityMetricSimilarityCallback_WithClosures,
wrap_DiffSimilarityMetricSimilarityCallback,
C_NoteCallback ,
NoteCallback ,
NoteCallback_WithClosures ,
drop_closures_NoteCallback ,
dynamic_NoteCallback ,
genClosure_NoteCallback ,
mk_NoteCallback ,
noNoteCallback ,
noNoteCallback_WithClosures ,
wrap_NoteCallback ,
C_ReferencesCallback ,
ReferencesCallback ,
ReferencesCallback_WithClosures ,
drop_closures_ReferencesCallback ,
dynamic_ReferencesCallback ,
genClosure_ReferencesCallback ,
mk_ReferencesCallback ,
noReferencesCallback ,
noReferencesCallback_WithClosures ,
wrap_ReferencesCallback ,
C_ReferencesNameCallback ,
ReferencesNameCallback ,
ReferencesNameCallback_WithClosures ,
drop_closures_ReferencesNameCallback ,
dynamic_ReferencesNameCallback ,
genClosure_ReferencesNameCallback ,
mk_ReferencesNameCallback ,
noReferencesNameCallback ,
noReferencesNameCallback_WithClosures ,
wrap_ReferencesNameCallback ,
C_RemoteListCallback ,
RemoteListCallback ,
RemoteListCallback_WithClosures ,
drop_closures_RemoteListCallback ,
dynamic_RemoteListCallback ,
genClosure_RemoteListCallback ,
mk_RemoteListCallback ,
noRemoteListCallback ,
noRemoteListCallback_WithClosures ,
wrap_RemoteListCallback ,
C_StashCallback ,
StashCallback ,
StashCallback_WithClosures ,
drop_closures_StashCallback ,
dynamic_StashCallback ,
genClosure_StashCallback ,
mk_StashCallback ,
noStashCallback ,
noStashCallback_WithClosures ,
wrap_StashCallback ,
C_StatusCallback ,
StatusCallback ,
StatusCallback_WithClosures ,
drop_closures_StatusCallback ,
dynamic_StatusCallback ,
genClosure_StatusCallback ,
mk_StatusCallback ,
noStatusCallback ,
noStatusCallback_WithClosures ,
wrap_StatusCallback ,
C_SubmoduleCallback ,
SubmoduleCallback ,
SubmoduleCallback_WithClosures ,
drop_closures_SubmoduleCallback ,
dynamic_SubmoduleCallback ,
genClosure_SubmoduleCallback ,
mk_SubmoduleCallback ,
noSubmoduleCallback ,
noSubmoduleCallback_WithClosures ,
wrap_SubmoduleCallback ,
C_TagCallback ,
TagCallback ,
TagCallback_WithClosures ,
drop_closures_TagCallback ,
dynamic_TagCallback ,
genClosure_TagCallback ,
mk_TagCallback ,
noTagCallback ,
noTagCallback_WithClosures ,
wrap_TagCallback ,
C_TransferProgressCallback ,
TransferProgressCallback ,
TransferProgressCallback_WithClosures ,
drop_closures_TransferProgressCallback ,
dynamic_TransferProgressCallback ,
genClosure_TransferProgressCallback ,
mk_TransferProgressCallback ,
noTransferProgressCallback ,
noTransferProgressCallback_WithClosures ,
wrap_TransferProgressCallback ,
C_TreeWalkCallback ,
TreeWalkCallback ,
TreeWalkCallback_WithClosures ,
drop_closures_TreeWalkCallback ,
dynamic_TreeWalkCallback ,
genClosure_TreeWalkCallback ,
mk_TreeWalkCallback ,
noTreeWalkCallback ,
noTreeWalkCallback_WithClosures ,
wrap_TreeWalkCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GLib.Structs.MatchInfo as GLib.MatchInfo
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Objects.Cred as Ggit.Cred
import {-# SOURCE #-} qualified GI.Ggit.Objects.Ref as Ggit.Ref
import {-# SOURCE #-} qualified GI.Ggit.Structs.ConfigEntry as Ggit.ConfigEntry
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffBinary as Ggit.DiffBinary
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffDelta as Ggit.DiffDelta
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffFile as Ggit.DiffFile
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffHunk as Ggit.DiffHunk
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffLine as Ggit.DiffLine
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.Submodule as Ggit.Submodule
import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress
import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry
type C_TreeWalkCallback =
CString ->
Ptr Ggit.TreeEntry.TreeEntry ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_TreeWalkCallback :: FunPtr C_TreeWalkCallback -> C_TreeWalkCallback
dynamic_TreeWalkCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TreeWalkCallback
-> T.Text
-> Ggit.TreeEntry.TreeEntry
-> Ptr ()
-> m Int32
dynamic_TreeWalkCallback :: FunPtr C_TreeWalkCallback -> Text -> TreeEntry -> Ptr () -> m Int32
dynamic_TreeWalkCallback FunPtr C_TreeWalkCallback
__funPtr Text
root TreeEntry
entry Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
root' <- Text -> IO CString
textToCString Text
root
Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
Int32
result <- (FunPtr C_TreeWalkCallback -> C_TreeWalkCallback
__dynamic_C_TreeWalkCallback FunPtr C_TreeWalkCallback
__funPtr) CString
root' Ptr TreeEntry
entry' Ptr ()
userData
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
root'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback)
type TreeWalkCallback =
T.Text
-> Ggit.TreeEntry.TreeEntry
-> IO Int32
noTreeWalkCallback :: Maybe TreeWalkCallback
noTreeWalkCallback :: Maybe TreeWalkCallback
noTreeWalkCallback = Maybe TreeWalkCallback
forall a. Maybe a
Nothing
type TreeWalkCallback_WithClosures =
T.Text
-> Ggit.TreeEntry.TreeEntry
-> Ptr ()
-> IO Int32
noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures
noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures
noTreeWalkCallback_WithClosures = Maybe TreeWalkCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures
drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures
drop_closures_TreeWalkCallback TreeWalkCallback
_f Text
root TreeEntry
entry Ptr ()
_ = TreeWalkCallback
_f Text
root TreeEntry
entry
genClosure_TreeWalkCallback :: MonadIO m => TreeWalkCallback -> m (GClosure C_TreeWalkCallback)
genClosure_TreeWalkCallback :: TreeWalkCallback -> m (GClosure C_TreeWalkCallback)
genClosure_TreeWalkCallback TreeWalkCallback
cb = IO (GClosure C_TreeWalkCallback) -> m (GClosure C_TreeWalkCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TreeWalkCallback)
-> m (GClosure C_TreeWalkCallback))
-> IO (GClosure C_TreeWalkCallback)
-> m (GClosure C_TreeWalkCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: TreeWalkCallback_WithClosures
cb' = TreeWalkCallback -> TreeWalkCallback_WithClosures
drop_closures_TreeWalkCallback TreeWalkCallback
cb
let cb'' :: C_TreeWalkCallback
cb'' = Maybe (Ptr (FunPtr C_TreeWalkCallback))
-> TreeWalkCallback_WithClosures -> C_TreeWalkCallback
wrap_TreeWalkCallback Maybe (Ptr (FunPtr C_TreeWalkCallback))
forall a. Maybe a
Nothing TreeWalkCallback_WithClosures
cb'
C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback)
mk_TreeWalkCallback C_TreeWalkCallback
cb'' IO (FunPtr C_TreeWalkCallback)
-> (FunPtr C_TreeWalkCallback -> IO (GClosure C_TreeWalkCallback))
-> IO (GClosure C_TreeWalkCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TreeWalkCallback -> IO (GClosure C_TreeWalkCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_TreeWalkCallback ::
Maybe (Ptr (FunPtr C_TreeWalkCallback)) ->
TreeWalkCallback_WithClosures ->
C_TreeWalkCallback
wrap_TreeWalkCallback :: Maybe (Ptr (FunPtr C_TreeWalkCallback))
-> TreeWalkCallback_WithClosures -> C_TreeWalkCallback
wrap_TreeWalkCallback Maybe (Ptr (FunPtr C_TreeWalkCallback))
funptrptr TreeWalkCallback_WithClosures
_cb CString
root Ptr TreeEntry
entry Ptr ()
userData = do
Text
root' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
root
(ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> (TreeEntry -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TreeEntry -> TreeEntry
Ggit.TreeEntry.TreeEntry Ptr TreeEntry
entry ((TreeEntry -> IO Int32) -> IO Int32)
-> (TreeEntry -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \TreeEntry
entry' -> do
Int32
result <- TreeWalkCallback_WithClosures
_cb Text
root' TreeEntry
entry' Ptr ()
userData
Maybe (Ptr (FunPtr C_TreeWalkCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TreeWalkCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_TransferProgressCallback =
Ptr Ggit.TransferProgress.TransferProgress ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_TransferProgressCallback :: FunPtr C_TransferProgressCallback -> C_TransferProgressCallback
dynamic_TransferProgressCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TransferProgressCallback
-> Ggit.TransferProgress.TransferProgress
-> Ptr ()
-> m Int32
dynamic_TransferProgressCallback :: FunPtr C_TransferProgressCallback
-> TransferProgress -> Ptr () -> m Int32
dynamic_TransferProgressCallback FunPtr C_TransferProgressCallback
__funPtr TransferProgress
stats Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr TransferProgress
stats' <- TransferProgress -> IO (Ptr TransferProgress)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TransferProgress
stats
Int32
result <- (FunPtr C_TransferProgressCallback -> C_TransferProgressCallback
__dynamic_C_TransferProgressCallback FunPtr C_TransferProgressCallback
__funPtr) Ptr TransferProgress
stats' Ptr ()
userData
TransferProgress -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TransferProgress
stats
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback)
type TransferProgressCallback =
Ggit.TransferProgress.TransferProgress
-> IO Int32
noTransferProgressCallback :: Maybe TransferProgressCallback
noTransferProgressCallback :: Maybe TransferProgressCallback
noTransferProgressCallback = Maybe TransferProgressCallback
forall a. Maybe a
Nothing
type TransferProgressCallback_WithClosures =
Ggit.TransferProgress.TransferProgress
-> Ptr ()
-> IO Int32
noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures
noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures
noTransferProgressCallback_WithClosures = Maybe TransferProgressCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures
drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures
drop_closures_TransferProgressCallback TransferProgressCallback
_f TransferProgress
stats Ptr ()
_ = TransferProgressCallback
_f TransferProgress
stats
genClosure_TransferProgressCallback :: MonadIO m => TransferProgressCallback -> m (GClosure C_TransferProgressCallback)
genClosure_TransferProgressCallback :: TransferProgressCallback -> m (GClosure C_TransferProgressCallback)
genClosure_TransferProgressCallback TransferProgressCallback
cb = IO (GClosure C_TransferProgressCallback)
-> m (GClosure C_TransferProgressCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TransferProgressCallback)
-> m (GClosure C_TransferProgressCallback))
-> IO (GClosure C_TransferProgressCallback)
-> m (GClosure C_TransferProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: TransferProgressCallback_WithClosures
cb' = TransferProgressCallback -> TransferProgressCallback_WithClosures
drop_closures_TransferProgressCallback TransferProgressCallback
cb
let cb'' :: C_TransferProgressCallback
cb'' = Maybe (Ptr (FunPtr C_TransferProgressCallback))
-> TransferProgressCallback_WithClosures
-> C_TransferProgressCallback
wrap_TransferProgressCallback Maybe (Ptr (FunPtr C_TransferProgressCallback))
forall a. Maybe a
Nothing TransferProgressCallback_WithClosures
cb'
C_TransferProgressCallback
-> IO (FunPtr C_TransferProgressCallback)
mk_TransferProgressCallback C_TransferProgressCallback
cb'' IO (FunPtr C_TransferProgressCallback)
-> (FunPtr C_TransferProgressCallback
-> IO (GClosure C_TransferProgressCallback))
-> IO (GClosure C_TransferProgressCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TransferProgressCallback
-> IO (GClosure C_TransferProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_TransferProgressCallback ::
Maybe (Ptr (FunPtr C_TransferProgressCallback)) ->
TransferProgressCallback_WithClosures ->
C_TransferProgressCallback
wrap_TransferProgressCallback :: Maybe (Ptr (FunPtr C_TransferProgressCallback))
-> TransferProgressCallback_WithClosures
-> C_TransferProgressCallback
wrap_TransferProgressCallback Maybe (Ptr (FunPtr C_TransferProgressCallback))
funptrptr TransferProgressCallback_WithClosures
_cb Ptr TransferProgress
stats Ptr ()
userData = do
(ManagedPtr TransferProgress -> TransferProgress)
-> Ptr TransferProgress -> TransferProgressCallback -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr TransferProgress -> TransferProgress
Ggit.TransferProgress.TransferProgress Ptr TransferProgress
stats (TransferProgressCallback -> IO Int32)
-> TransferProgressCallback -> IO Int32
forall a b. (a -> b) -> a -> b
$ \TransferProgress
stats' -> do
Int32
result <- TransferProgressCallback_WithClosures
_cb TransferProgress
stats' Ptr ()
userData
Maybe (Ptr (FunPtr C_TransferProgressCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TransferProgressCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_TagCallback =
CString ->
Ptr Ggit.OId.OId ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_TagCallback :: FunPtr C_TagCallback -> C_TagCallback
dynamic_TagCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TagCallback
-> T.Text
-> Ggit.OId.OId
-> Ptr ()
-> m Int32
dynamic_TagCallback :: FunPtr C_TagCallback -> Text -> OId -> Ptr () -> m Int32
dynamic_TagCallback FunPtr C_TagCallback
__funPtr Text
name OId
tagOid Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr OId
tagOid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
tagOid
Int32
result <- (FunPtr C_TagCallback -> C_TagCallback
__dynamic_C_TagCallback FunPtr C_TagCallback
__funPtr) CString
name' Ptr OId
tagOid' Ptr ()
userData
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
tagOid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback)
type TagCallback =
T.Text
-> Ggit.OId.OId
-> IO Int32
noTagCallback :: Maybe TagCallback
noTagCallback :: Maybe TagCallback
noTagCallback = Maybe TagCallback
forall a. Maybe a
Nothing
type TagCallback_WithClosures =
T.Text
-> Ggit.OId.OId
-> Ptr ()
-> IO Int32
noTagCallback_WithClosures :: Maybe TagCallback_WithClosures
noTagCallback_WithClosures :: Maybe TagCallback_WithClosures
noTagCallback_WithClosures = Maybe TagCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures
drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures
drop_closures_TagCallback TagCallback
_f Text
name OId
tagOid Ptr ()
_ = TagCallback
_f Text
name OId
tagOid
genClosure_TagCallback :: MonadIO m => TagCallback -> m (GClosure C_TagCallback)
genClosure_TagCallback :: TagCallback -> m (GClosure C_TagCallback)
genClosure_TagCallback TagCallback
cb = IO (GClosure C_TagCallback) -> m (GClosure C_TagCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TagCallback) -> m (GClosure C_TagCallback))
-> IO (GClosure C_TagCallback) -> m (GClosure C_TagCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: TagCallback_WithClosures
cb' = TagCallback -> TagCallback_WithClosures
drop_closures_TagCallback TagCallback
cb
let cb'' :: C_TagCallback
cb'' = Maybe (Ptr (FunPtr C_TagCallback))
-> TagCallback_WithClosures -> C_TagCallback
wrap_TagCallback Maybe (Ptr (FunPtr C_TagCallback))
forall a. Maybe a
Nothing TagCallback_WithClosures
cb'
C_TagCallback -> IO (FunPtr C_TagCallback)
mk_TagCallback C_TagCallback
cb'' IO (FunPtr C_TagCallback)
-> (FunPtr C_TagCallback -> IO (GClosure C_TagCallback))
-> IO (GClosure C_TagCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TagCallback -> IO (GClosure C_TagCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_TagCallback ::
Maybe (Ptr (FunPtr C_TagCallback)) ->
TagCallback_WithClosures ->
C_TagCallback
wrap_TagCallback :: Maybe (Ptr (FunPtr C_TagCallback))
-> TagCallback_WithClosures -> C_TagCallback
wrap_TagCallback Maybe (Ptr (FunPtr C_TagCallback))
funptrptr TagCallback_WithClosures
_cb CString
name Ptr OId
tagOid Ptr ()
userData = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
tagOid ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
tagOid' -> do
Int32
result <- TagCallback_WithClosures
_cb Text
name' OId
tagOid' Ptr ()
userData
Maybe (Ptr (FunPtr C_TagCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TagCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_SubmoduleCallback =
Ptr Ggit.Submodule.Submodule ->
CString ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_SubmoduleCallback :: FunPtr C_SubmoduleCallback -> C_SubmoduleCallback
dynamic_SubmoduleCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_SubmoduleCallback
-> Ggit.Submodule.Submodule
-> T.Text
-> Ptr ()
-> m Int32
dynamic_SubmoduleCallback :: FunPtr C_SubmoduleCallback
-> Submodule -> Text -> Ptr () -> m Int32
dynamic_SubmoduleCallback FunPtr C_SubmoduleCallback
__funPtr Submodule
submodule Text
name Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Submodule
submodule' <- Submodule -> IO (Ptr Submodule)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Submodule
submodule
CString
name' <- Text -> IO CString
textToCString Text
name
Int32
result <- (FunPtr C_SubmoduleCallback -> C_SubmoduleCallback
__dynamic_C_SubmoduleCallback FunPtr C_SubmoduleCallback
__funPtr) Ptr Submodule
submodule' CString
name' Ptr ()
userData
Submodule -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Submodule
submodule
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback)
type SubmoduleCallback =
Ggit.Submodule.Submodule
-> T.Text
-> IO Int32
noSubmoduleCallback :: Maybe SubmoduleCallback
noSubmoduleCallback :: Maybe SubmoduleCallback
noSubmoduleCallback = Maybe SubmoduleCallback
forall a. Maybe a
Nothing
type SubmoduleCallback_WithClosures =
Ggit.Submodule.Submodule
-> T.Text
-> Ptr ()
-> IO Int32
noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures
noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures
noSubmoduleCallback_WithClosures = Maybe SubmoduleCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures
drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures
drop_closures_SubmoduleCallback SubmoduleCallback
_f Submodule
submodule Text
name Ptr ()
_ = SubmoduleCallback
_f Submodule
submodule Text
name
genClosure_SubmoduleCallback :: MonadIO m => SubmoduleCallback -> m (GClosure C_SubmoduleCallback)
genClosure_SubmoduleCallback :: SubmoduleCallback -> m (GClosure C_SubmoduleCallback)
genClosure_SubmoduleCallback SubmoduleCallback
cb = IO (GClosure C_SubmoduleCallback)
-> m (GClosure C_SubmoduleCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SubmoduleCallback)
-> m (GClosure C_SubmoduleCallback))
-> IO (GClosure C_SubmoduleCallback)
-> m (GClosure C_SubmoduleCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: SubmoduleCallback_WithClosures
cb' = SubmoduleCallback -> SubmoduleCallback_WithClosures
drop_closures_SubmoduleCallback SubmoduleCallback
cb
let cb'' :: C_SubmoduleCallback
cb'' = Maybe (Ptr (FunPtr C_SubmoduleCallback))
-> SubmoduleCallback_WithClosures -> C_SubmoduleCallback
wrap_SubmoduleCallback Maybe (Ptr (FunPtr C_SubmoduleCallback))
forall a. Maybe a
Nothing SubmoduleCallback_WithClosures
cb'
C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback)
mk_SubmoduleCallback C_SubmoduleCallback
cb'' IO (FunPtr C_SubmoduleCallback)
-> (FunPtr C_SubmoduleCallback
-> IO (GClosure C_SubmoduleCallback))
-> IO (GClosure C_SubmoduleCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SubmoduleCallback -> IO (GClosure C_SubmoduleCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SubmoduleCallback ::
Maybe (Ptr (FunPtr C_SubmoduleCallback)) ->
SubmoduleCallback_WithClosures ->
C_SubmoduleCallback
wrap_SubmoduleCallback :: Maybe (Ptr (FunPtr C_SubmoduleCallback))
-> SubmoduleCallback_WithClosures -> C_SubmoduleCallback
wrap_SubmoduleCallback Maybe (Ptr (FunPtr C_SubmoduleCallback))
funptrptr SubmoduleCallback_WithClosures
_cb Ptr Submodule
submodule CString
name Ptr ()
userData = do
(ManagedPtr Submodule -> Submodule)
-> Ptr Submodule -> (Submodule -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Submodule -> Submodule
Ggit.Submodule.Submodule Ptr Submodule
submodule ((Submodule -> IO Int32) -> IO Int32)
-> (Submodule -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Submodule
submodule' -> do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Int32
result <- SubmoduleCallback_WithClosures
_cb Submodule
submodule' Text
name' Ptr ()
userData
Maybe (Ptr (FunPtr C_SubmoduleCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SubmoduleCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_StatusCallback =
CString ->
CUInt ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_StatusCallback :: FunPtr C_StatusCallback -> C_StatusCallback
dynamic_StatusCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_StatusCallback
-> T.Text
-> [Ggit.Flags.StatusFlags]
-> Ptr ()
-> m Int32
dynamic_StatusCallback :: FunPtr C_StatusCallback
-> Text -> [StatusFlags] -> Ptr () -> m Int32
dynamic_StatusCallback FunPtr C_StatusCallback
__funPtr Text
path [StatusFlags]
statusFlags Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
let statusFlags' :: CUInt
statusFlags' = [StatusFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StatusFlags]
statusFlags
Int32
result <- (FunPtr C_StatusCallback -> C_StatusCallback
__dynamic_C_StatusCallback FunPtr C_StatusCallback
__funPtr) CString
path' CUInt
statusFlags' Ptr ()
userData
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback)
type StatusCallback =
T.Text
-> [Ggit.Flags.StatusFlags]
-> IO Int32
noStatusCallback :: Maybe StatusCallback
noStatusCallback :: Maybe StatusCallback
noStatusCallback = Maybe StatusCallback
forall a. Maybe a
Nothing
type StatusCallback_WithClosures =
T.Text
-> [Ggit.Flags.StatusFlags]
-> Ptr ()
-> IO Int32
noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures
noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures
noStatusCallback_WithClosures = Maybe StatusCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures
drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures
drop_closures_StatusCallback StatusCallback
_f Text
path [StatusFlags]
statusFlags Ptr ()
_ = StatusCallback
_f Text
path [StatusFlags]
statusFlags
genClosure_StatusCallback :: MonadIO m => StatusCallback -> m (GClosure C_StatusCallback)
genClosure_StatusCallback :: StatusCallback -> m (GClosure C_StatusCallback)
genClosure_StatusCallback StatusCallback
cb = IO (GClosure C_StatusCallback) -> m (GClosure C_StatusCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_StatusCallback) -> m (GClosure C_StatusCallback))
-> IO (GClosure C_StatusCallback) -> m (GClosure C_StatusCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: StatusCallback_WithClosures
cb' = StatusCallback -> StatusCallback_WithClosures
drop_closures_StatusCallback StatusCallback
cb
let cb'' :: C_StatusCallback
cb'' = Maybe (Ptr (FunPtr C_StatusCallback))
-> StatusCallback_WithClosures -> C_StatusCallback
wrap_StatusCallback Maybe (Ptr (FunPtr C_StatusCallback))
forall a. Maybe a
Nothing StatusCallback_WithClosures
cb'
C_StatusCallback -> IO (FunPtr C_StatusCallback)
mk_StatusCallback C_StatusCallback
cb'' IO (FunPtr C_StatusCallback)
-> (FunPtr C_StatusCallback -> IO (GClosure C_StatusCallback))
-> IO (GClosure C_StatusCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_StatusCallback -> IO (GClosure C_StatusCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_StatusCallback ::
Maybe (Ptr (FunPtr C_StatusCallback)) ->
StatusCallback_WithClosures ->
C_StatusCallback
wrap_StatusCallback :: Maybe (Ptr (FunPtr C_StatusCallback))
-> StatusCallback_WithClosures -> C_StatusCallback
wrap_StatusCallback Maybe (Ptr (FunPtr C_StatusCallback))
funptrptr StatusCallback_WithClosures
_cb CString
path CUInt
statusFlags Ptr ()
userData = do
Text
path' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
path
let statusFlags' :: [StatusFlags]
statusFlags' = CUInt -> [StatusFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
statusFlags
Int32
result <- StatusCallback_WithClosures
_cb Text
path' [StatusFlags]
statusFlags' Ptr ()
userData
Maybe (Ptr (FunPtr C_StatusCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_StatusCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_StashCallback =
Word64 ->
CString ->
Ptr Ggit.OId.OId ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_StashCallback :: FunPtr C_StashCallback -> C_StashCallback
dynamic_StashCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_StashCallback
-> Word64
-> T.Text
-> Ggit.OId.OId
-> Ptr ()
-> m Int32
dynamic_StashCallback :: FunPtr C_StashCallback
-> Word64 -> Text -> OId -> Ptr () -> m Int32
dynamic_StashCallback FunPtr C_StashCallback
__funPtr Word64
index Text
message OId
stashOid Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
message' <- Text -> IO CString
textToCString Text
message
Ptr OId
stashOid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
stashOid
Int32
result <- (FunPtr C_StashCallback -> C_StashCallback
__dynamic_C_StashCallback FunPtr C_StashCallback
__funPtr) Word64
index CString
message' Ptr OId
stashOid' Ptr ()
userData
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
stashOid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
message'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback)
type StashCallback =
Word64
-> T.Text
-> Ggit.OId.OId
-> IO Int32
noStashCallback :: Maybe StashCallback
noStashCallback :: Maybe StashCallback
noStashCallback = Maybe StashCallback
forall a. Maybe a
Nothing
type StashCallback_WithClosures =
Word64
-> T.Text
-> Ggit.OId.OId
-> Ptr ()
-> IO Int32
noStashCallback_WithClosures :: Maybe StashCallback_WithClosures
noStashCallback_WithClosures :: Maybe StashCallback_WithClosures
noStashCallback_WithClosures = Maybe StashCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures
drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures
drop_closures_StashCallback StashCallback
_f Word64
index Text
message OId
stashOid Ptr ()
_ = StashCallback
_f Word64
index Text
message OId
stashOid
genClosure_StashCallback :: MonadIO m => StashCallback -> m (GClosure C_StashCallback)
genClosure_StashCallback :: StashCallback -> m (GClosure C_StashCallback)
genClosure_StashCallback StashCallback
cb = IO (GClosure C_StashCallback) -> m (GClosure C_StashCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_StashCallback) -> m (GClosure C_StashCallback))
-> IO (GClosure C_StashCallback) -> m (GClosure C_StashCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: StashCallback_WithClosures
cb' = StashCallback -> StashCallback_WithClosures
drop_closures_StashCallback StashCallback
cb
let cb'' :: C_StashCallback
cb'' = Maybe (Ptr (FunPtr C_StashCallback))
-> StashCallback_WithClosures -> C_StashCallback
wrap_StashCallback Maybe (Ptr (FunPtr C_StashCallback))
forall a. Maybe a
Nothing StashCallback_WithClosures
cb'
C_StashCallback -> IO (FunPtr C_StashCallback)
mk_StashCallback C_StashCallback
cb'' IO (FunPtr C_StashCallback)
-> (FunPtr C_StashCallback -> IO (GClosure C_StashCallback))
-> IO (GClosure C_StashCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_StashCallback -> IO (GClosure C_StashCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_StashCallback ::
Maybe (Ptr (FunPtr C_StashCallback)) ->
StashCallback_WithClosures ->
C_StashCallback
wrap_StashCallback :: Maybe (Ptr (FunPtr C_StashCallback))
-> StashCallback_WithClosures -> C_StashCallback
wrap_StashCallback Maybe (Ptr (FunPtr C_StashCallback))
funptrptr StashCallback_WithClosures
_cb Word64
index CString
message Ptr OId
stashOid Ptr ()
userData = do
Text
message' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
message
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
stashOid ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
stashOid' -> do
Int32
result <- StashCallback_WithClosures
_cb Word64
index Text
message' OId
stashOid' Ptr ()
userData
Maybe (Ptr (FunPtr C_StashCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_StashCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_RemoteListCallback =
CString ->
Ptr Ggit.OId.OId ->
Ptr Ggit.OId.OId ->
CInt ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_RemoteListCallback :: FunPtr C_RemoteListCallback -> C_RemoteListCallback
dynamic_RemoteListCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_RemoteListCallback
-> T.Text
-> Ggit.OId.OId
-> Ggit.OId.OId
-> Bool
-> Ptr ()
-> m Int32
dynamic_RemoteListCallback :: FunPtr C_RemoteListCallback
-> Text -> OId -> OId -> Bool -> Ptr () -> m Int32
dynamic_RemoteListCallback FunPtr C_RemoteListCallback
__funPtr Text
name OId
oid OId
loid Bool
local Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
Ptr OId
loid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
loid
let local' :: CInt
local' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
local
Int32
result <- (FunPtr C_RemoteListCallback -> C_RemoteListCallback
__dynamic_C_RemoteListCallback FunPtr C_RemoteListCallback
__funPtr) CString
name' Ptr OId
oid' Ptr OId
loid' CInt
local' Ptr ()
userData
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
loid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback)
type RemoteListCallback =
T.Text
-> Ggit.OId.OId
-> Ggit.OId.OId
-> Bool
-> IO Int32
noRemoteListCallback :: Maybe RemoteListCallback
noRemoteListCallback :: Maybe RemoteListCallback
noRemoteListCallback = Maybe RemoteListCallback
forall a. Maybe a
Nothing
type RemoteListCallback_WithClosures =
T.Text
-> Ggit.OId.OId
-> Ggit.OId.OId
-> Bool
-> Ptr ()
-> IO Int32
noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures
noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures
noRemoteListCallback_WithClosures = Maybe RemoteListCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures
drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures
drop_closures_RemoteListCallback RemoteListCallback
_f Text
name OId
oid OId
loid Bool
local Ptr ()
_ = RemoteListCallback
_f Text
name OId
oid OId
loid Bool
local
genClosure_RemoteListCallback :: MonadIO m => RemoteListCallback -> m (GClosure C_RemoteListCallback)
genClosure_RemoteListCallback :: RemoteListCallback -> m (GClosure C_RemoteListCallback)
genClosure_RemoteListCallback RemoteListCallback
cb = IO (GClosure C_RemoteListCallback)
-> m (GClosure C_RemoteListCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RemoteListCallback)
-> m (GClosure C_RemoteListCallback))
-> IO (GClosure C_RemoteListCallback)
-> m (GClosure C_RemoteListCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: RemoteListCallback_WithClosures
cb' = RemoteListCallback -> RemoteListCallback_WithClosures
drop_closures_RemoteListCallback RemoteListCallback
cb
let cb'' :: C_RemoteListCallback
cb'' = Maybe (Ptr (FunPtr C_RemoteListCallback))
-> RemoteListCallback_WithClosures -> C_RemoteListCallback
wrap_RemoteListCallback Maybe (Ptr (FunPtr C_RemoteListCallback))
forall a. Maybe a
Nothing RemoteListCallback_WithClosures
cb'
C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback)
mk_RemoteListCallback C_RemoteListCallback
cb'' IO (FunPtr C_RemoteListCallback)
-> (FunPtr C_RemoteListCallback
-> IO (GClosure C_RemoteListCallback))
-> IO (GClosure C_RemoteListCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RemoteListCallback -> IO (GClosure C_RemoteListCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RemoteListCallback ::
Maybe (Ptr (FunPtr C_RemoteListCallback)) ->
RemoteListCallback_WithClosures ->
C_RemoteListCallback
wrap_RemoteListCallback :: Maybe (Ptr (FunPtr C_RemoteListCallback))
-> RemoteListCallback_WithClosures -> C_RemoteListCallback
wrap_RemoteListCallback Maybe (Ptr (FunPtr C_RemoteListCallback))
funptrptr RemoteListCallback_WithClosures
_cb CString
name Ptr OId
oid Ptr OId
loid CInt
local Ptr ()
userData = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
oid ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
oid' -> do
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
loid ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
loid' -> do
let local' :: Bool
local' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
local
Int32
result <- RemoteListCallback_WithClosures
_cb Text
name' OId
oid' OId
loid' Bool
local' Ptr ()
userData
Maybe (Ptr (FunPtr C_RemoteListCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_RemoteListCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_ReferencesNameCallback =
CString ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_ReferencesNameCallback :: FunPtr C_ReferencesNameCallback -> C_ReferencesNameCallback
dynamic_ReferencesNameCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ReferencesNameCallback
-> T.Text
-> Ptr ()
-> m Int32
dynamic_ReferencesNameCallback :: FunPtr C_ReferencesNameCallback -> Text -> Ptr () -> m Int32
dynamic_ReferencesNameCallback FunPtr C_ReferencesNameCallback
__funPtr Text
name Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Int32
result <- (FunPtr C_ReferencesNameCallback -> C_ReferencesNameCallback
__dynamic_C_ReferencesNameCallback FunPtr C_ReferencesNameCallback
__funPtr) CString
name' Ptr ()
userData
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback)
type ReferencesNameCallback =
T.Text
-> IO Int32
noReferencesNameCallback :: Maybe ReferencesNameCallback
noReferencesNameCallback :: Maybe ReferencesNameCallback
noReferencesNameCallback = Maybe ReferencesNameCallback
forall a. Maybe a
Nothing
type ReferencesNameCallback_WithClosures =
T.Text
-> Ptr ()
-> IO Int32
noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures
noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures
noReferencesNameCallback_WithClosures = Maybe ReferencesNameCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures
drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures
drop_closures_ReferencesNameCallback ReferencesNameCallback
_f Text
name Ptr ()
_ = ReferencesNameCallback
_f Text
name
genClosure_ReferencesNameCallback :: MonadIO m => ReferencesNameCallback -> m (GClosure C_ReferencesNameCallback)
genClosure_ReferencesNameCallback :: ReferencesNameCallback -> m (GClosure C_ReferencesNameCallback)
genClosure_ReferencesNameCallback ReferencesNameCallback
cb = IO (GClosure C_ReferencesNameCallback)
-> m (GClosure C_ReferencesNameCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ReferencesNameCallback)
-> m (GClosure C_ReferencesNameCallback))
-> IO (GClosure C_ReferencesNameCallback)
-> m (GClosure C_ReferencesNameCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ReferencesNameCallback_WithClosures
cb' = ReferencesNameCallback -> ReferencesNameCallback_WithClosures
drop_closures_ReferencesNameCallback ReferencesNameCallback
cb
let cb'' :: C_ReferencesNameCallback
cb'' = Maybe (Ptr (FunPtr C_ReferencesNameCallback))
-> ReferencesNameCallback_WithClosures -> C_ReferencesNameCallback
wrap_ReferencesNameCallback Maybe (Ptr (FunPtr C_ReferencesNameCallback))
forall a. Maybe a
Nothing ReferencesNameCallback_WithClosures
cb'
C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback)
mk_ReferencesNameCallback C_ReferencesNameCallback
cb'' IO (FunPtr C_ReferencesNameCallback)
-> (FunPtr C_ReferencesNameCallback
-> IO (GClosure C_ReferencesNameCallback))
-> IO (GClosure C_ReferencesNameCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ReferencesNameCallback
-> IO (GClosure C_ReferencesNameCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ReferencesNameCallback ::
Maybe (Ptr (FunPtr C_ReferencesNameCallback)) ->
ReferencesNameCallback_WithClosures ->
C_ReferencesNameCallback
wrap_ReferencesNameCallback :: Maybe (Ptr (FunPtr C_ReferencesNameCallback))
-> ReferencesNameCallback_WithClosures -> C_ReferencesNameCallback
wrap_ReferencesNameCallback Maybe (Ptr (FunPtr C_ReferencesNameCallback))
funptrptr ReferencesNameCallback_WithClosures
_cb CString
name Ptr ()
userData = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Int32
result <- ReferencesNameCallback_WithClosures
_cb Text
name' Ptr ()
userData
Maybe (Ptr (FunPtr C_ReferencesNameCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ReferencesNameCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_ReferencesCallback =
Ptr Ggit.Ref.Ref ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_ReferencesCallback :: FunPtr C_ReferencesCallback -> C_ReferencesCallback
dynamic_ReferencesCallback ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Ref.IsRef a) =>
FunPtr C_ReferencesCallback
-> a
-> Ptr ()
-> m Int32
dynamic_ReferencesCallback :: FunPtr C_ReferencesCallback -> a -> Ptr () -> m Int32
dynamic_ReferencesCallback FunPtr C_ReferencesCallback
__funPtr a
reference Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
reference' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject a
reference
Int32
result <- (FunPtr C_ReferencesCallback -> C_ReferencesCallback
__dynamic_C_ReferencesCallback FunPtr C_ReferencesCallback
__funPtr) Ptr Ref
reference' Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reference
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback)
type ReferencesCallback =
Ggit.Ref.Ref
-> IO Int32
noReferencesCallback :: Maybe ReferencesCallback
noReferencesCallback :: Maybe ReferencesCallback
noReferencesCallback = Maybe ReferencesCallback
forall a. Maybe a
Nothing
type ReferencesCallback_WithClosures =
Ggit.Ref.Ref
-> Ptr ()
-> IO Int32
noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures
noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures
noReferencesCallback_WithClosures = Maybe ReferencesCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures
drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures
drop_closures_ReferencesCallback ReferencesCallback
_f Ref
reference Ptr ()
_ = ReferencesCallback
_f Ref
reference
genClosure_ReferencesCallback :: MonadIO m => ReferencesCallback -> m (GClosure C_ReferencesCallback)
genClosure_ReferencesCallback :: ReferencesCallback -> m (GClosure C_ReferencesCallback)
genClosure_ReferencesCallback ReferencesCallback
cb = IO (GClosure C_ReferencesCallback)
-> m (GClosure C_ReferencesCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ReferencesCallback)
-> m (GClosure C_ReferencesCallback))
-> IO (GClosure C_ReferencesCallback)
-> m (GClosure C_ReferencesCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ReferencesCallback_WithClosures
cb' = ReferencesCallback -> ReferencesCallback_WithClosures
drop_closures_ReferencesCallback ReferencesCallback
cb
let cb'' :: C_ReferencesCallback
cb'' = Maybe (Ptr (FunPtr C_ReferencesCallback))
-> ReferencesCallback_WithClosures -> C_ReferencesCallback
wrap_ReferencesCallback Maybe (Ptr (FunPtr C_ReferencesCallback))
forall a. Maybe a
Nothing ReferencesCallback_WithClosures
cb'
C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback)
mk_ReferencesCallback C_ReferencesCallback
cb'' IO (FunPtr C_ReferencesCallback)
-> (FunPtr C_ReferencesCallback
-> IO (GClosure C_ReferencesCallback))
-> IO (GClosure C_ReferencesCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ReferencesCallback -> IO (GClosure C_ReferencesCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ReferencesCallback ::
Maybe (Ptr (FunPtr C_ReferencesCallback)) ->
ReferencesCallback_WithClosures ->
C_ReferencesCallback
wrap_ReferencesCallback :: Maybe (Ptr (FunPtr C_ReferencesCallback))
-> ReferencesCallback_WithClosures -> C_ReferencesCallback
wrap_ReferencesCallback Maybe (Ptr (FunPtr C_ReferencesCallback))
funptrptr ReferencesCallback_WithClosures
_cb Ptr Ref
reference Ptr ()
userData = do
Ref
reference' <- ((ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Ref -> Ref
Ggit.Ref.Ref) Ptr Ref
reference
Int32
result <- ReferencesCallback_WithClosures
_cb Ref
reference' Ptr ()
userData
Maybe (Ptr (FunPtr C_ReferencesCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ReferencesCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_NoteCallback =
Ptr Ggit.OId.OId ->
Ptr Ggit.OId.OId ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_NoteCallback :: FunPtr C_NoteCallback -> C_NoteCallback
dynamic_NoteCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_NoteCallback
-> Ggit.OId.OId
-> Ggit.OId.OId
-> Ptr ()
-> m Int32
dynamic_NoteCallback :: FunPtr C_NoteCallback -> OId -> OId -> Ptr () -> m Int32
dynamic_NoteCallback FunPtr C_NoteCallback
__funPtr OId
blobId OId
annotatedObjectId Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
blobId' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
blobId
Ptr OId
annotatedObjectId' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
annotatedObjectId
Int32
result <- (FunPtr C_NoteCallback -> C_NoteCallback
__dynamic_C_NoteCallback FunPtr C_NoteCallback
__funPtr) Ptr OId
blobId' Ptr OId
annotatedObjectId' Ptr ()
userData
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
blobId
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
annotatedObjectId
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback)
type NoteCallback =
Ggit.OId.OId
-> Ggit.OId.OId
-> IO Int32
noNoteCallback :: Maybe NoteCallback
noNoteCallback :: Maybe NoteCallback
noNoteCallback = Maybe NoteCallback
forall a. Maybe a
Nothing
type NoteCallback_WithClosures =
Ggit.OId.OId
-> Ggit.OId.OId
-> Ptr ()
-> IO Int32
noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures
noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures
noNoteCallback_WithClosures = Maybe NoteCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures
drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures
drop_closures_NoteCallback NoteCallback
_f OId
blobId OId
annotatedObjectId Ptr ()
_ = NoteCallback
_f OId
blobId OId
annotatedObjectId
genClosure_NoteCallback :: MonadIO m => NoteCallback -> m (GClosure C_NoteCallback)
genClosure_NoteCallback :: NoteCallback -> m (GClosure C_NoteCallback)
genClosure_NoteCallback NoteCallback
cb = IO (GClosure C_NoteCallback) -> m (GClosure C_NoteCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_NoteCallback) -> m (GClosure C_NoteCallback))
-> IO (GClosure C_NoteCallback) -> m (GClosure C_NoteCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: NoteCallback_WithClosures
cb' = NoteCallback -> NoteCallback_WithClosures
drop_closures_NoteCallback NoteCallback
cb
let cb'' :: C_NoteCallback
cb'' = Maybe (Ptr (FunPtr C_NoteCallback))
-> NoteCallback_WithClosures -> C_NoteCallback
wrap_NoteCallback Maybe (Ptr (FunPtr C_NoteCallback))
forall a. Maybe a
Nothing NoteCallback_WithClosures
cb'
C_NoteCallback -> IO (FunPtr C_NoteCallback)
mk_NoteCallback C_NoteCallback
cb'' IO (FunPtr C_NoteCallback)
-> (FunPtr C_NoteCallback -> IO (GClosure C_NoteCallback))
-> IO (GClosure C_NoteCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_NoteCallback -> IO (GClosure C_NoteCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_NoteCallback ::
Maybe (Ptr (FunPtr C_NoteCallback)) ->
NoteCallback_WithClosures ->
C_NoteCallback
wrap_NoteCallback :: Maybe (Ptr (FunPtr C_NoteCallback))
-> NoteCallback_WithClosures -> C_NoteCallback
wrap_NoteCallback Maybe (Ptr (FunPtr C_NoteCallback))
funptrptr NoteCallback_WithClosures
_cb Ptr OId
blobId Ptr OId
annotatedObjectId Ptr ()
userData = do
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
blobId ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
blobId' -> do
(ManagedPtr OId -> OId) -> Ptr OId -> (OId -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr OId -> OId
Ggit.OId.OId Ptr OId
annotatedObjectId ((OId -> IO Int32) -> IO Int32) -> (OId -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \OId
annotatedObjectId' -> do
Int32
result <- NoteCallback_WithClosures
_cb OId
blobId' OId
annotatedObjectId' Ptr ()
userData
Maybe (Ptr (FunPtr C_NoteCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_NoteCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffSimilarityMetricSimilarityCallback =
Int32 ->
Ptr () ->
Ptr () ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricSimilarityCallback :: FunPtr C_DiffSimilarityMetricSimilarityCallback -> C_DiffSimilarityMetricSimilarityCallback
dynamic_DiffSimilarityMetricSimilarityCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffSimilarityMetricSimilarityCallback
-> Int32
-> Ptr ()
-> Ptr ()
-> Ptr ()
-> m Int32
dynamic_DiffSimilarityMetricSimilarityCallback :: FunPtr C_DiffSimilarityMetricSimilarityCallback
-> Int32 -> Ptr () -> Ptr () -> Ptr () -> m Int32
dynamic_DiffSimilarityMetricSimilarityCallback FunPtr C_DiffSimilarityMetricSimilarityCallback
__funPtr Int32
score Ptr ()
signatureA Ptr ()
signatureB Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Int32
result <- (FunPtr C_DiffSimilarityMetricSimilarityCallback
-> C_DiffSimilarityMetricSimilarityCallback
__dynamic_C_DiffSimilarityMetricSimilarityCallback FunPtr C_DiffSimilarityMetricSimilarityCallback
__funPtr) Int32
score Ptr ()
signatureA Ptr ()
signatureB Ptr ()
userData
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffSimilarityMetricSimilarityCallback :: C_DiffSimilarityMetricSimilarityCallback -> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)
type DiffSimilarityMetricSimilarityCallback =
Int32
-> Ptr ()
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback
noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback
noDiffSimilarityMetricSimilarityCallback = Maybe DiffSimilarityMetricSimilarityCallback
forall a. Maybe a
Nothing
type DiffSimilarityMetricSimilarityCallback_WithClosures =
Int32
-> Ptr ()
-> Ptr ()
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures
noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe C_DiffSimilarityMetricSimilarityCallback
noDiffSimilarityMetricSimilarityCallback_WithClosures = Maybe C_DiffSimilarityMetricSimilarityCallback
forall a. Maybe a
Nothing
drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures
drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback
-> C_DiffSimilarityMetricSimilarityCallback
drop_closures_DiffSimilarityMetricSimilarityCallback DiffSimilarityMetricSimilarityCallback
_f Int32
score Ptr ()
signatureA Ptr ()
signatureB Ptr ()
_ = DiffSimilarityMetricSimilarityCallback
_f Int32
score Ptr ()
signatureA Ptr ()
signatureB
genClosure_DiffSimilarityMetricSimilarityCallback :: MonadIO m => DiffSimilarityMetricSimilarityCallback -> m (GClosure C_DiffSimilarityMetricSimilarityCallback)
genClosure_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback
-> m (GClosure C_DiffSimilarityMetricSimilarityCallback)
genClosure_DiffSimilarityMetricSimilarityCallback DiffSimilarityMetricSimilarityCallback
cb = IO (GClosure C_DiffSimilarityMetricSimilarityCallback)
-> m (GClosure C_DiffSimilarityMetricSimilarityCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffSimilarityMetricSimilarityCallback)
-> m (GClosure C_DiffSimilarityMetricSimilarityCallback))
-> IO (GClosure C_DiffSimilarityMetricSimilarityCallback)
-> m (GClosure C_DiffSimilarityMetricSimilarityCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiffSimilarityMetricSimilarityCallback
cb' = DiffSimilarityMetricSimilarityCallback
-> C_DiffSimilarityMetricSimilarityCallback
drop_closures_DiffSimilarityMetricSimilarityCallback DiffSimilarityMetricSimilarityCallback
cb
let cb'' :: C_DiffSimilarityMetricSimilarityCallback
cb'' = Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
-> C_DiffSimilarityMetricSimilarityCallback
-> C_DiffSimilarityMetricSimilarityCallback
wrap_DiffSimilarityMetricSimilarityCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
forall a. Maybe a
Nothing C_DiffSimilarityMetricSimilarityCallback
cb'
C_DiffSimilarityMetricSimilarityCallback
-> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)
mk_DiffSimilarityMetricSimilarityCallback C_DiffSimilarityMetricSimilarityCallback
cb'' IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)
-> (FunPtr C_DiffSimilarityMetricSimilarityCallback
-> IO (GClosure C_DiffSimilarityMetricSimilarityCallback))
-> IO (GClosure C_DiffSimilarityMetricSimilarityCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffSimilarityMetricSimilarityCallback
-> IO (GClosure C_DiffSimilarityMetricSimilarityCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffSimilarityMetricSimilarityCallback ::
Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback)) ->
DiffSimilarityMetricSimilarityCallback_WithClosures ->
C_DiffSimilarityMetricSimilarityCallback
wrap_DiffSimilarityMetricSimilarityCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
-> C_DiffSimilarityMetricSimilarityCallback
-> C_DiffSimilarityMetricSimilarityCallback
wrap_DiffSimilarityMetricSimilarityCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
funptrptr C_DiffSimilarityMetricSimilarityCallback
_cb Int32
score Ptr ()
signatureA Ptr ()
signatureB Ptr ()
userData = do
Int32
result <- C_DiffSimilarityMetricSimilarityCallback
_cb Int32
score Ptr ()
signatureA Ptr ()
signatureB Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffSimilarityMetricFreeSignatureCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricFreeSignatureCallback :: FunPtr C_DiffSimilarityMetricFreeSignatureCallback -> C_DiffSimilarityMetricFreeSignatureCallback
dynamic_DiffSimilarityMetricFreeSignatureCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffSimilarityMetricFreeSignatureCallback
-> Ptr ()
-> Ptr ()
-> m ()
dynamic_DiffSimilarityMetricFreeSignatureCallback :: FunPtr C_DiffSimilarityMetricFreeSignatureCallback
-> Ptr () -> Ptr () -> m ()
dynamic_DiffSimilarityMetricFreeSignatureCallback FunPtr C_DiffSimilarityMetricFreeSignatureCallback
__funPtr Ptr ()
signature Ptr ()
userData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
(FunPtr C_DiffSimilarityMetricFreeSignatureCallback
-> C_DiffSimilarityMetricFreeSignatureCallback
__dynamic_C_DiffSimilarityMetricFreeSignatureCallback FunPtr C_DiffSimilarityMetricFreeSignatureCallback
__funPtr) Ptr ()
signature Ptr ()
userData
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_DiffSimilarityMetricFreeSignatureCallback :: C_DiffSimilarityMetricFreeSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)
type DiffSimilarityMetricFreeSignatureCallback =
Ptr ()
-> IO ()
noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback
noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback
noDiffSimilarityMetricFreeSignatureCallback = Maybe DiffSimilarityMetricFreeSignatureCallback
forall a. Maybe a
Nothing
type DiffSimilarityMetricFreeSignatureCallback_WithClosures =
Ptr ()
-> Ptr ()
-> IO ()
noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures
noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe C_DiffSimilarityMetricFreeSignatureCallback
noDiffSimilarityMetricFreeSignatureCallback_WithClosures = Maybe C_DiffSimilarityMetricFreeSignatureCallback
forall a. Maybe a
Nothing
drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback
-> C_DiffSimilarityMetricFreeSignatureCallback
drop_closures_DiffSimilarityMetricFreeSignatureCallback DiffSimilarityMetricFreeSignatureCallback
_f Ptr ()
signature Ptr ()
_ = DiffSimilarityMetricFreeSignatureCallback
_f Ptr ()
signature
genClosure_DiffSimilarityMetricFreeSignatureCallback :: MonadIO m => DiffSimilarityMetricFreeSignatureCallback -> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
genClosure_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback
-> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
genClosure_DiffSimilarityMetricFreeSignatureCallback DiffSimilarityMetricFreeSignatureCallback
cb = IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiffSimilarityMetricFreeSignatureCallback
cb' = DiffSimilarityMetricFreeSignatureCallback
-> C_DiffSimilarityMetricFreeSignatureCallback
drop_closures_DiffSimilarityMetricFreeSignatureCallback DiffSimilarityMetricFreeSignatureCallback
cb
let cb'' :: C_DiffSimilarityMetricFreeSignatureCallback
cb'' = Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
-> C_DiffSimilarityMetricFreeSignatureCallback
-> C_DiffSimilarityMetricFreeSignatureCallback
wrap_DiffSimilarityMetricFreeSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
forall a. Maybe a
Nothing C_DiffSimilarityMetricFreeSignatureCallback
cb'
C_DiffSimilarityMetricFreeSignatureCallback
-> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)
mk_DiffSimilarityMetricFreeSignatureCallback C_DiffSimilarityMetricFreeSignatureCallback
cb'' IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)
-> (FunPtr C_DiffSimilarityMetricFreeSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffSimilarityMetricFreeSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricFreeSignatureCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffSimilarityMetricFreeSignatureCallback ::
Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)) ->
DiffSimilarityMetricFreeSignatureCallback_WithClosures ->
C_DiffSimilarityMetricFreeSignatureCallback
wrap_DiffSimilarityMetricFreeSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
-> C_DiffSimilarityMetricFreeSignatureCallback
-> C_DiffSimilarityMetricFreeSignatureCallback
wrap_DiffSimilarityMetricFreeSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
funptrptr C_DiffSimilarityMetricFreeSignatureCallback
_cb Ptr ()
signature Ptr ()
userData = do
C_DiffSimilarityMetricFreeSignatureCallback
_cb Ptr ()
signature Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback))
funptrptr
type C_DiffSimilarityMetricFileSignatureCallback =
Ptr Ggit.DiffFile.DiffFile ->
CString ->
Ptr () ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricFileSignatureCallback :: FunPtr C_DiffSimilarityMetricFileSignatureCallback -> C_DiffSimilarityMetricFileSignatureCallback
dynamic_DiffSimilarityMetricFileSignatureCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffSimilarityMetricFileSignatureCallback
-> Ggit.DiffFile.DiffFile
-> T.Text
-> Ptr ()
-> Ptr ()
-> m Int32
dynamic_DiffSimilarityMetricFileSignatureCallback :: FunPtr C_DiffSimilarityMetricFileSignatureCallback
-> DiffFile -> Text -> Ptr () -> Ptr () -> m Int32
dynamic_DiffSimilarityMetricFileSignatureCallback FunPtr C_DiffSimilarityMetricFileSignatureCallback
__funPtr DiffFile
file Text
fullpath Ptr ()
out Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFile
file' <- DiffFile -> IO (Ptr DiffFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffFile
file
CString
fullpath' <- Text -> IO CString
textToCString Text
fullpath
Int32
result <- (FunPtr C_DiffSimilarityMetricFileSignatureCallback
-> C_DiffSimilarityMetricFileSignatureCallback
__dynamic_C_DiffSimilarityMetricFileSignatureCallback FunPtr C_DiffSimilarityMetricFileSignatureCallback
__funPtr) Ptr DiffFile
file' CString
fullpath' Ptr ()
out Ptr ()
userData
DiffFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffFile
file
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
fullpath'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffSimilarityMetricFileSignatureCallback :: C_DiffSimilarityMetricFileSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)
type DiffSimilarityMetricFileSignatureCallback =
Ggit.DiffFile.DiffFile
-> T.Text
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback
noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback
noDiffSimilarityMetricFileSignatureCallback = Maybe DiffSimilarityMetricFileSignatureCallback
forall a. Maybe a
Nothing
type DiffSimilarityMetricFileSignatureCallback_WithClosures =
Ggit.DiffFile.DiffFile
-> T.Text
-> Ptr ()
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures
noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures
noDiffSimilarityMetricFileSignatureCallback_WithClosures = Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback
-> DiffSimilarityMetricFileSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricFileSignatureCallback DiffSimilarityMetricFileSignatureCallback
_f DiffFile
file Text
fullpath Ptr ()
out Ptr ()
_ = DiffSimilarityMetricFileSignatureCallback
_f DiffFile
file Text
fullpath Ptr ()
out
genClosure_DiffSimilarityMetricFileSignatureCallback :: MonadIO m => DiffSimilarityMetricFileSignatureCallback -> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)
genClosure_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback
-> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)
genClosure_DiffSimilarityMetricFileSignatureCallback DiffSimilarityMetricFileSignatureCallback
cb = IO (GClosure C_DiffSimilarityMetricFileSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffSimilarityMetricFileSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFileSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricFileSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffSimilarityMetricFileSignatureCallback_WithClosures
cb' = DiffSimilarityMetricFileSignatureCallback
-> DiffSimilarityMetricFileSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricFileSignatureCallback DiffSimilarityMetricFileSignatureCallback
cb
let cb'' :: C_DiffSimilarityMetricFileSignatureCallback
cb'' = Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
-> DiffSimilarityMetricFileSignatureCallback_WithClosures
-> C_DiffSimilarityMetricFileSignatureCallback
wrap_DiffSimilarityMetricFileSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
forall a. Maybe a
Nothing DiffSimilarityMetricFileSignatureCallback_WithClosures
cb'
C_DiffSimilarityMetricFileSignatureCallback
-> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)
mk_DiffSimilarityMetricFileSignatureCallback C_DiffSimilarityMetricFileSignatureCallback
cb'' IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)
-> (FunPtr C_DiffSimilarityMetricFileSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricFileSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricFileSignatureCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffSimilarityMetricFileSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricFileSignatureCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffSimilarityMetricFileSignatureCallback ::
Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback)) ->
DiffSimilarityMetricFileSignatureCallback_WithClosures ->
C_DiffSimilarityMetricFileSignatureCallback
wrap_DiffSimilarityMetricFileSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
-> DiffSimilarityMetricFileSignatureCallback_WithClosures
-> C_DiffSimilarityMetricFileSignatureCallback
wrap_DiffSimilarityMetricFileSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
funptrptr DiffSimilarityMetricFileSignatureCallback_WithClosures
_cb Ptr DiffFile
file CString
fullpath Ptr ()
out Ptr ()
userData = do
(ManagedPtr DiffFile -> DiffFile)
-> Ptr DiffFile -> (DiffFile -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffFile -> DiffFile
Ggit.DiffFile.DiffFile Ptr DiffFile
file ((DiffFile -> IO Int32) -> IO Int32)
-> (DiffFile -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffFile
file' -> do
Text
fullpath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
fullpath
Int32
result <- DiffSimilarityMetricFileSignatureCallback_WithClosures
_cb DiffFile
file' Text
fullpath' Ptr ()
out Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffSimilarityMetricBufferSignatureCallback =
Ptr Ggit.DiffFile.DiffFile ->
CString ->
Word64 ->
Ptr () ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricBufferSignatureCallback :: FunPtr C_DiffSimilarityMetricBufferSignatureCallback -> C_DiffSimilarityMetricBufferSignatureCallback
dynamic_DiffSimilarityMetricBufferSignatureCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffSimilarityMetricBufferSignatureCallback
-> Ggit.DiffFile.DiffFile
-> T.Text
-> Word64
-> Ptr ()
-> Ptr ()
-> m Int32
dynamic_DiffSimilarityMetricBufferSignatureCallback :: FunPtr C_DiffSimilarityMetricBufferSignatureCallback
-> DiffFile -> Text -> Word64 -> Ptr () -> Ptr () -> m Int32
dynamic_DiffSimilarityMetricBufferSignatureCallback FunPtr C_DiffSimilarityMetricBufferSignatureCallback
__funPtr DiffFile
file Text
buf Word64
buflen Ptr ()
out Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFile
file' <- DiffFile -> IO (Ptr DiffFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffFile
file
CString
buf' <- Text -> IO CString
textToCString Text
buf
Int32
result <- (FunPtr C_DiffSimilarityMetricBufferSignatureCallback
-> C_DiffSimilarityMetricBufferSignatureCallback
__dynamic_C_DiffSimilarityMetricBufferSignatureCallback FunPtr C_DiffSimilarityMetricBufferSignatureCallback
__funPtr) Ptr DiffFile
file' CString
buf' Word64
buflen Ptr ()
out Ptr ()
userData
DiffFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffFile
file
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
buf'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffSimilarityMetricBufferSignatureCallback :: C_DiffSimilarityMetricBufferSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)
type DiffSimilarityMetricBufferSignatureCallback =
Ggit.DiffFile.DiffFile
-> T.Text
-> Word64
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback
noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback
noDiffSimilarityMetricBufferSignatureCallback = Maybe DiffSimilarityMetricBufferSignatureCallback
forall a. Maybe a
Nothing
type DiffSimilarityMetricBufferSignatureCallback_WithClosures =
Ggit.DiffFile.DiffFile
-> T.Text
-> Word64
-> Ptr ()
-> Ptr ()
-> IO Int32
noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures
noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures
noDiffSimilarityMetricBufferSignatureCallback_WithClosures = Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback
-> DiffSimilarityMetricBufferSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricBufferSignatureCallback DiffSimilarityMetricBufferSignatureCallback
_f DiffFile
file Text
buf Word64
buflen Ptr ()
out Ptr ()
_ = DiffSimilarityMetricBufferSignatureCallback
_f DiffFile
file Text
buf Word64
buflen Ptr ()
out
genClosure_DiffSimilarityMetricBufferSignatureCallback :: MonadIO m => DiffSimilarityMetricBufferSignatureCallback -> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
genClosure_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback
-> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
genClosure_DiffSimilarityMetricBufferSignatureCallback DiffSimilarityMetricBufferSignatureCallback
cb = IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
-> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffSimilarityMetricBufferSignatureCallback_WithClosures
cb' = DiffSimilarityMetricBufferSignatureCallback
-> DiffSimilarityMetricBufferSignatureCallback_WithClosures
drop_closures_DiffSimilarityMetricBufferSignatureCallback DiffSimilarityMetricBufferSignatureCallback
cb
let cb'' :: C_DiffSimilarityMetricBufferSignatureCallback
cb'' = Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
-> DiffSimilarityMetricBufferSignatureCallback_WithClosures
-> C_DiffSimilarityMetricBufferSignatureCallback
wrap_DiffSimilarityMetricBufferSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
forall a. Maybe a
Nothing DiffSimilarityMetricBufferSignatureCallback_WithClosures
cb'
C_DiffSimilarityMetricBufferSignatureCallback
-> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)
mk_DiffSimilarityMetricBufferSignatureCallback C_DiffSimilarityMetricBufferSignatureCallback
cb'' IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)
-> (FunPtr C_DiffSimilarityMetricBufferSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback))
-> IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffSimilarityMetricBufferSignatureCallback
-> IO (GClosure C_DiffSimilarityMetricBufferSignatureCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffSimilarityMetricBufferSignatureCallback ::
Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)) ->
DiffSimilarityMetricBufferSignatureCallback_WithClosures ->
C_DiffSimilarityMetricBufferSignatureCallback
wrap_DiffSimilarityMetricBufferSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
-> DiffSimilarityMetricBufferSignatureCallback_WithClosures
-> C_DiffSimilarityMetricBufferSignatureCallback
wrap_DiffSimilarityMetricBufferSignatureCallback Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
funptrptr DiffSimilarityMetricBufferSignatureCallback_WithClosures
_cb Ptr DiffFile
file CString
buf Word64
buflen Ptr ()
out Ptr ()
userData = do
(ManagedPtr DiffFile -> DiffFile)
-> Ptr DiffFile -> (DiffFile -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffFile -> DiffFile
Ggit.DiffFile.DiffFile Ptr DiffFile
file ((DiffFile -> IO Int32) -> IO Int32)
-> (DiffFile -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffFile
file' -> do
Text
buf' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
buf
Int32
result <- DiffSimilarityMetricBufferSignatureCallback_WithClosures
_cb DiffFile
file' Text
buf' Word64
buflen Ptr ()
out Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffLineCallback =
Ptr Ggit.DiffDelta.DiffDelta ->
Ptr Ggit.DiffHunk.DiffHunk ->
Ptr Ggit.DiffLine.DiffLine ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffLineCallback :: FunPtr C_DiffLineCallback -> C_DiffLineCallback
dynamic_DiffLineCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffLineCallback
-> Ggit.DiffDelta.DiffDelta
-> Maybe (Ggit.DiffHunk.DiffHunk)
-> Ggit.DiffLine.DiffLine
-> Ptr ()
-> m Int32
dynamic_DiffLineCallback :: FunPtr C_DiffLineCallback
-> DiffDelta -> Maybe DiffHunk -> DiffLine -> Ptr () -> m Int32
dynamic_DiffLineCallback FunPtr C_DiffLineCallback
__funPtr DiffDelta
delta Maybe DiffHunk
hunk DiffLine
line Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffDelta
delta' <- DiffDelta -> IO (Ptr DiffDelta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffDelta
delta
Ptr DiffHunk
maybeHunk <- case Maybe DiffHunk
hunk of
Maybe DiffHunk
Nothing -> Ptr DiffHunk -> IO (Ptr DiffHunk)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DiffHunk
forall a. Ptr a
nullPtr
Just DiffHunk
jHunk -> do
Ptr DiffHunk
jHunk' <- DiffHunk -> IO (Ptr DiffHunk)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffHunk
jHunk
Ptr DiffHunk -> IO (Ptr DiffHunk)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DiffHunk
jHunk'
Ptr DiffLine
line' <- DiffLine -> IO (Ptr DiffLine)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffLine
line
Int32
result <- (FunPtr C_DiffLineCallback -> C_DiffLineCallback
__dynamic_C_DiffLineCallback FunPtr C_DiffLineCallback
__funPtr) Ptr DiffDelta
delta' Ptr DiffHunk
maybeHunk Ptr DiffLine
line' Ptr ()
userData
DiffDelta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffDelta
delta
Maybe DiffHunk -> (DiffHunk -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe DiffHunk
hunk DiffHunk -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
DiffLine -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffLine
line
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback)
type DiffLineCallback =
Ggit.DiffDelta.DiffDelta
-> Maybe Ggit.DiffHunk.DiffHunk
-> Ggit.DiffLine.DiffLine
-> IO Int32
noDiffLineCallback :: Maybe DiffLineCallback
noDiffLineCallback :: Maybe DiffLineCallback
noDiffLineCallback = Maybe DiffLineCallback
forall a. Maybe a
Nothing
type DiffLineCallback_WithClosures =
Ggit.DiffDelta.DiffDelta
-> Maybe Ggit.DiffHunk.DiffHunk
-> Ggit.DiffLine.DiffLine
-> Ptr ()
-> IO Int32
noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures
noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures
noDiffLineCallback_WithClosures = Maybe DiffLineCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures
drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures
drop_closures_DiffLineCallback DiffLineCallback
_f DiffDelta
delta Maybe DiffHunk
hunk DiffLine
line Ptr ()
_ = DiffLineCallback
_f DiffDelta
delta Maybe DiffHunk
hunk DiffLine
line
genClosure_DiffLineCallback :: MonadIO m => DiffLineCallback -> m (GClosure C_DiffLineCallback)
genClosure_DiffLineCallback :: DiffLineCallback -> m (GClosure C_DiffLineCallback)
genClosure_DiffLineCallback DiffLineCallback
cb = IO (GClosure C_DiffLineCallback) -> m (GClosure C_DiffLineCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffLineCallback)
-> m (GClosure C_DiffLineCallback))
-> IO (GClosure C_DiffLineCallback)
-> m (GClosure C_DiffLineCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffLineCallback_WithClosures
cb' = DiffLineCallback -> DiffLineCallback_WithClosures
drop_closures_DiffLineCallback DiffLineCallback
cb
let cb'' :: C_DiffLineCallback
cb'' = Maybe (Ptr (FunPtr C_DiffLineCallback))
-> DiffLineCallback_WithClosures -> C_DiffLineCallback
wrap_DiffLineCallback Maybe (Ptr (FunPtr C_DiffLineCallback))
forall a. Maybe a
Nothing DiffLineCallback_WithClosures
cb'
C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback)
mk_DiffLineCallback C_DiffLineCallback
cb'' IO (FunPtr C_DiffLineCallback)
-> (FunPtr C_DiffLineCallback -> IO (GClosure C_DiffLineCallback))
-> IO (GClosure C_DiffLineCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffLineCallback -> IO (GClosure C_DiffLineCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffLineCallback ::
Maybe (Ptr (FunPtr C_DiffLineCallback)) ->
DiffLineCallback_WithClosures ->
C_DiffLineCallback
wrap_DiffLineCallback :: Maybe (Ptr (FunPtr C_DiffLineCallback))
-> DiffLineCallback_WithClosures -> C_DiffLineCallback
wrap_DiffLineCallback Maybe (Ptr (FunPtr C_DiffLineCallback))
funptrptr DiffLineCallback_WithClosures
_cb Ptr DiffDelta
delta Ptr DiffHunk
hunk Ptr DiffLine
line Ptr ()
userData = do
(ManagedPtr DiffDelta -> DiffDelta)
-> Ptr DiffDelta -> (DiffDelta -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffDelta -> DiffDelta
Ggit.DiffDelta.DiffDelta Ptr DiffDelta
delta ((DiffDelta -> IO Int32) -> IO Int32)
-> (DiffDelta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffDelta
delta' -> do
Maybe DiffHunk
maybeHunk <-
if Ptr DiffHunk
hunk Ptr DiffHunk -> Ptr DiffHunk -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr DiffHunk
forall a. Ptr a
nullPtr
then Maybe DiffHunk -> IO (Maybe DiffHunk)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffHunk
forall a. Maybe a
Nothing
else do
(ManagedPtr DiffHunk -> DiffHunk)
-> Ptr DiffHunk
-> (DiffHunk -> IO (Maybe DiffHunk))
-> IO (Maybe DiffHunk)
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffHunk -> DiffHunk
Ggit.DiffHunk.DiffHunk Ptr DiffHunk
hunk ((DiffHunk -> IO (Maybe DiffHunk)) -> IO (Maybe DiffHunk))
-> (DiffHunk -> IO (Maybe DiffHunk)) -> IO (Maybe DiffHunk)
forall a b. (a -> b) -> a -> b
$ \DiffHunk
hunk' -> do
Maybe DiffHunk -> IO (Maybe DiffHunk)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe DiffHunk -> IO (Maybe DiffHunk))
-> Maybe DiffHunk -> IO (Maybe DiffHunk)
forall a b. (a -> b) -> a -> b
$ DiffHunk -> Maybe DiffHunk
forall a. a -> Maybe a
Just DiffHunk
hunk'
(ManagedPtr DiffLine -> DiffLine)
-> Ptr DiffLine -> (DiffLine -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffLine -> DiffLine
Ggit.DiffLine.DiffLine Ptr DiffLine
line ((DiffLine -> IO Int32) -> IO Int32)
-> (DiffLine -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffLine
line' -> do
Int32
result <- DiffLineCallback_WithClosures
_cb DiffDelta
delta' Maybe DiffHunk
maybeHunk DiffLine
line' Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffLineCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffLineCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffHunkCallback =
Ptr Ggit.DiffDelta.DiffDelta ->
Ptr Ggit.DiffHunk.DiffHunk ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffHunkCallback :: FunPtr C_DiffHunkCallback -> C_DiffHunkCallback
dynamic_DiffHunkCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffHunkCallback
-> Ggit.DiffDelta.DiffDelta
-> Ggit.DiffHunk.DiffHunk
-> Ptr ()
-> m Int32
dynamic_DiffHunkCallback :: FunPtr C_DiffHunkCallback
-> DiffDelta -> DiffHunk -> Ptr () -> m Int32
dynamic_DiffHunkCallback FunPtr C_DiffHunkCallback
__funPtr DiffDelta
delta DiffHunk
hunk Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffDelta
delta' <- DiffDelta -> IO (Ptr DiffDelta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffDelta
delta
Ptr DiffHunk
hunk' <- DiffHunk -> IO (Ptr DiffHunk)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffHunk
hunk
Int32
result <- (FunPtr C_DiffHunkCallback -> C_DiffHunkCallback
__dynamic_C_DiffHunkCallback FunPtr C_DiffHunkCallback
__funPtr) Ptr DiffDelta
delta' Ptr DiffHunk
hunk' Ptr ()
userData
DiffDelta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffDelta
delta
DiffHunk -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffHunk
hunk
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback)
type DiffHunkCallback =
Ggit.DiffDelta.DiffDelta
-> Ggit.DiffHunk.DiffHunk
-> IO Int32
noDiffHunkCallback :: Maybe DiffHunkCallback
noDiffHunkCallback :: Maybe DiffHunkCallback
noDiffHunkCallback = Maybe DiffHunkCallback
forall a. Maybe a
Nothing
type DiffHunkCallback_WithClosures =
Ggit.DiffDelta.DiffDelta
-> Ggit.DiffHunk.DiffHunk
-> Ptr ()
-> IO Int32
noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures
noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures
noDiffHunkCallback_WithClosures = Maybe DiffHunkCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures
drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures
drop_closures_DiffHunkCallback DiffHunkCallback
_f DiffDelta
delta DiffHunk
hunk Ptr ()
_ = DiffHunkCallback
_f DiffDelta
delta DiffHunk
hunk
genClosure_DiffHunkCallback :: MonadIO m => DiffHunkCallback -> m (GClosure C_DiffHunkCallback)
genClosure_DiffHunkCallback :: DiffHunkCallback -> m (GClosure C_DiffHunkCallback)
genClosure_DiffHunkCallback DiffHunkCallback
cb = IO (GClosure C_DiffHunkCallback) -> m (GClosure C_DiffHunkCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffHunkCallback)
-> m (GClosure C_DiffHunkCallback))
-> IO (GClosure C_DiffHunkCallback)
-> m (GClosure C_DiffHunkCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffHunkCallback_WithClosures
cb' = DiffHunkCallback -> DiffHunkCallback_WithClosures
drop_closures_DiffHunkCallback DiffHunkCallback
cb
let cb'' :: C_DiffHunkCallback
cb'' = Maybe (Ptr (FunPtr C_DiffHunkCallback))
-> DiffHunkCallback_WithClosures -> C_DiffHunkCallback
wrap_DiffHunkCallback Maybe (Ptr (FunPtr C_DiffHunkCallback))
forall a. Maybe a
Nothing DiffHunkCallback_WithClosures
cb'
C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback)
mk_DiffHunkCallback C_DiffHunkCallback
cb'' IO (FunPtr C_DiffHunkCallback)
-> (FunPtr C_DiffHunkCallback -> IO (GClosure C_DiffHunkCallback))
-> IO (GClosure C_DiffHunkCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffHunkCallback -> IO (GClosure C_DiffHunkCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffHunkCallback ::
Maybe (Ptr (FunPtr C_DiffHunkCallback)) ->
DiffHunkCallback_WithClosures ->
C_DiffHunkCallback
wrap_DiffHunkCallback :: Maybe (Ptr (FunPtr C_DiffHunkCallback))
-> DiffHunkCallback_WithClosures -> C_DiffHunkCallback
wrap_DiffHunkCallback Maybe (Ptr (FunPtr C_DiffHunkCallback))
funptrptr DiffHunkCallback_WithClosures
_cb Ptr DiffDelta
delta Ptr DiffHunk
hunk Ptr ()
userData = do
(ManagedPtr DiffDelta -> DiffDelta)
-> Ptr DiffDelta -> (DiffDelta -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffDelta -> DiffDelta
Ggit.DiffDelta.DiffDelta Ptr DiffDelta
delta ((DiffDelta -> IO Int32) -> IO Int32)
-> (DiffDelta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffDelta
delta' -> do
(ManagedPtr DiffHunk -> DiffHunk)
-> Ptr DiffHunk -> (DiffHunk -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffHunk -> DiffHunk
Ggit.DiffHunk.DiffHunk Ptr DiffHunk
hunk ((DiffHunk -> IO Int32) -> IO Int32)
-> (DiffHunk -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffHunk
hunk' -> do
Int32
result <- DiffHunkCallback_WithClosures
_cb DiffDelta
delta' DiffHunk
hunk' Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffHunkCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffHunkCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffFileCallback =
Ptr Ggit.DiffDelta.DiffDelta ->
CFloat ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffFileCallback :: FunPtr C_DiffFileCallback -> C_DiffFileCallback
dynamic_DiffFileCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffFileCallback
-> Ggit.DiffDelta.DiffDelta
-> Float
-> Ptr ()
-> m Int32
dynamic_DiffFileCallback :: FunPtr C_DiffFileCallback
-> DiffDelta -> Float -> Ptr () -> m Int32
dynamic_DiffFileCallback FunPtr C_DiffFileCallback
__funPtr DiffDelta
delta Float
progress Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffDelta
delta' <- DiffDelta -> IO (Ptr DiffDelta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffDelta
delta
let progress' :: CFloat
progress' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
progress
Int32
result <- (FunPtr C_DiffFileCallback -> C_DiffFileCallback
__dynamic_C_DiffFileCallback FunPtr C_DiffFileCallback
__funPtr) Ptr DiffDelta
delta' CFloat
progress' Ptr ()
userData
DiffDelta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffDelta
delta
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback)
type DiffFileCallback =
Ggit.DiffDelta.DiffDelta
-> Float
-> IO Int32
noDiffFileCallback :: Maybe DiffFileCallback
noDiffFileCallback :: Maybe DiffFileCallback
noDiffFileCallback = Maybe DiffFileCallback
forall a. Maybe a
Nothing
type DiffFileCallback_WithClosures =
Ggit.DiffDelta.DiffDelta
-> Float
-> Ptr ()
-> IO Int32
noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures
noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures
noDiffFileCallback_WithClosures = Maybe DiffFileCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures
drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures
drop_closures_DiffFileCallback DiffFileCallback
_f DiffDelta
delta Float
progress Ptr ()
_ = DiffFileCallback
_f DiffDelta
delta Float
progress
genClosure_DiffFileCallback :: MonadIO m => DiffFileCallback -> m (GClosure C_DiffFileCallback)
genClosure_DiffFileCallback :: DiffFileCallback -> m (GClosure C_DiffFileCallback)
genClosure_DiffFileCallback DiffFileCallback
cb = IO (GClosure C_DiffFileCallback) -> m (GClosure C_DiffFileCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffFileCallback)
-> m (GClosure C_DiffFileCallback))
-> IO (GClosure C_DiffFileCallback)
-> m (GClosure C_DiffFileCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffFileCallback_WithClosures
cb' = DiffFileCallback -> DiffFileCallback_WithClosures
drop_closures_DiffFileCallback DiffFileCallback
cb
let cb'' :: C_DiffFileCallback
cb'' = Maybe (Ptr (FunPtr C_DiffFileCallback))
-> DiffFileCallback_WithClosures -> C_DiffFileCallback
wrap_DiffFileCallback Maybe (Ptr (FunPtr C_DiffFileCallback))
forall a. Maybe a
Nothing DiffFileCallback_WithClosures
cb'
C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback)
mk_DiffFileCallback C_DiffFileCallback
cb'' IO (FunPtr C_DiffFileCallback)
-> (FunPtr C_DiffFileCallback -> IO (GClosure C_DiffFileCallback))
-> IO (GClosure C_DiffFileCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffFileCallback -> IO (GClosure C_DiffFileCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffFileCallback ::
Maybe (Ptr (FunPtr C_DiffFileCallback)) ->
DiffFileCallback_WithClosures ->
C_DiffFileCallback
wrap_DiffFileCallback :: Maybe (Ptr (FunPtr C_DiffFileCallback))
-> DiffFileCallback_WithClosures -> C_DiffFileCallback
wrap_DiffFileCallback Maybe (Ptr (FunPtr C_DiffFileCallback))
funptrptr DiffFileCallback_WithClosures
_cb Ptr DiffDelta
delta CFloat
progress Ptr ()
userData = do
(ManagedPtr DiffDelta -> DiffDelta)
-> Ptr DiffDelta -> (DiffDelta -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffDelta -> DiffDelta
Ggit.DiffDelta.DiffDelta Ptr DiffDelta
delta ((DiffDelta -> IO Int32) -> IO Int32)
-> (DiffDelta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffDelta
delta' -> do
let progress' :: Float
progress' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
progress
Int32
result <- DiffFileCallback_WithClosures
_cb DiffDelta
delta' Float
progress' Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffFileCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffFileCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_DiffBinaryCallback =
Ptr Ggit.DiffDelta.DiffDelta ->
Ptr Ggit.DiffBinary.DiffBinary ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_DiffBinaryCallback :: FunPtr C_DiffBinaryCallback -> C_DiffBinaryCallback
dynamic_DiffBinaryCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_DiffBinaryCallback
-> Ggit.DiffDelta.DiffDelta
-> Ggit.DiffBinary.DiffBinary
-> Ptr ()
-> m Int32
dynamic_DiffBinaryCallback :: FunPtr C_DiffBinaryCallback
-> DiffDelta -> DiffBinary -> Ptr () -> m Int32
dynamic_DiffBinaryCallback FunPtr C_DiffBinaryCallback
__funPtr DiffDelta
delta DiffBinary
binary Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffDelta
delta' <- DiffDelta -> IO (Ptr DiffDelta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffDelta
delta
Ptr DiffBinary
binary' <- DiffBinary -> IO (Ptr DiffBinary)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinary
binary
Int32
result <- (FunPtr C_DiffBinaryCallback -> C_DiffBinaryCallback
__dynamic_C_DiffBinaryCallback FunPtr C_DiffBinaryCallback
__funPtr) Ptr DiffDelta
delta' Ptr DiffBinary
binary' Ptr ()
userData
DiffDelta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffDelta
delta
DiffBinary -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinary
binary
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback)
type DiffBinaryCallback =
Ggit.DiffDelta.DiffDelta
-> Ggit.DiffBinary.DiffBinary
-> IO Int32
noDiffBinaryCallback :: Maybe DiffBinaryCallback
noDiffBinaryCallback :: Maybe DiffBinaryCallback
noDiffBinaryCallback = Maybe DiffBinaryCallback
forall a. Maybe a
Nothing
type DiffBinaryCallback_WithClosures =
Ggit.DiffDelta.DiffDelta
-> Ggit.DiffBinary.DiffBinary
-> Ptr ()
-> IO Int32
noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures
noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures
noDiffBinaryCallback_WithClosures = Maybe DiffBinaryCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures
drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures
drop_closures_DiffBinaryCallback DiffBinaryCallback
_f DiffDelta
delta DiffBinary
binary Ptr ()
_ = DiffBinaryCallback
_f DiffDelta
delta DiffBinary
binary
genClosure_DiffBinaryCallback :: MonadIO m => DiffBinaryCallback -> m (GClosure C_DiffBinaryCallback)
genClosure_DiffBinaryCallback :: DiffBinaryCallback -> m (GClosure C_DiffBinaryCallback)
genClosure_DiffBinaryCallback DiffBinaryCallback
cb = IO (GClosure C_DiffBinaryCallback)
-> m (GClosure C_DiffBinaryCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiffBinaryCallback)
-> m (GClosure C_DiffBinaryCallback))
-> IO (GClosure C_DiffBinaryCallback)
-> m (GClosure C_DiffBinaryCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: DiffBinaryCallback_WithClosures
cb' = DiffBinaryCallback -> DiffBinaryCallback_WithClosures
drop_closures_DiffBinaryCallback DiffBinaryCallback
cb
let cb'' :: C_DiffBinaryCallback
cb'' = Maybe (Ptr (FunPtr C_DiffBinaryCallback))
-> DiffBinaryCallback_WithClosures -> C_DiffBinaryCallback
wrap_DiffBinaryCallback Maybe (Ptr (FunPtr C_DiffBinaryCallback))
forall a. Maybe a
Nothing DiffBinaryCallback_WithClosures
cb'
C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback)
mk_DiffBinaryCallback C_DiffBinaryCallback
cb'' IO (FunPtr C_DiffBinaryCallback)
-> (FunPtr C_DiffBinaryCallback
-> IO (GClosure C_DiffBinaryCallback))
-> IO (GClosure C_DiffBinaryCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiffBinaryCallback -> IO (GClosure C_DiffBinaryCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiffBinaryCallback ::
Maybe (Ptr (FunPtr C_DiffBinaryCallback)) ->
DiffBinaryCallback_WithClosures ->
C_DiffBinaryCallback
wrap_DiffBinaryCallback :: Maybe (Ptr (FunPtr C_DiffBinaryCallback))
-> DiffBinaryCallback_WithClosures -> C_DiffBinaryCallback
wrap_DiffBinaryCallback Maybe (Ptr (FunPtr C_DiffBinaryCallback))
funptrptr DiffBinaryCallback_WithClosures
_cb Ptr DiffDelta
delta Ptr DiffBinary
binary Ptr ()
userData = do
(ManagedPtr DiffDelta -> DiffDelta)
-> Ptr DiffDelta -> (DiffDelta -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffDelta -> DiffDelta
Ggit.DiffDelta.DiffDelta Ptr DiffDelta
delta ((DiffDelta -> IO Int32) -> IO Int32)
-> (DiffDelta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffDelta
delta' -> do
(ManagedPtr DiffBinary -> DiffBinary)
-> Ptr DiffBinary -> (DiffBinary -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr DiffBinary -> DiffBinary
Ggit.DiffBinary.DiffBinary Ptr DiffBinary
binary ((DiffBinary -> IO Int32) -> IO Int32)
-> (DiffBinary -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \DiffBinary
binary' -> do
Int32
result <- DiffBinaryCallback_WithClosures
_cb DiffDelta
delta' DiffBinary
binary' Ptr ()
userData
Maybe (Ptr (FunPtr C_DiffBinaryCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DiffBinaryCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_CredAcquireCallback =
CString ->
CString ->
Word32 ->
Ptr Ggit.Cred.Cred ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_CredAcquireCallback :: FunPtr C_CredAcquireCallback -> C_CredAcquireCallback
dynamic_CredAcquireCallback ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Cred.IsCred a) =>
FunPtr C_CredAcquireCallback
-> T.Text
-> Maybe (T.Text)
-> Word32
-> a
-> Ptr ()
-> m Int32
dynamic_CredAcquireCallback :: FunPtr C_CredAcquireCallback
-> Text -> Maybe Text -> Word32 -> a -> Ptr () -> m Int32
dynamic_CredAcquireCallback FunPtr C_CredAcquireCallback
__funPtr Text
url Maybe Text
usernameFromUrl Word32
allowedTypes a
cred Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
CString
url' <- Text -> IO CString
textToCString Text
url
CString
maybeUsernameFromUrl <- case Maybe Text
usernameFromUrl of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jUsernameFromUrl -> do
CString
jUsernameFromUrl' <- Text -> IO CString
textToCString Text
jUsernameFromUrl
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUsernameFromUrl'
Ptr Cred
cred' <- a -> IO (Ptr Cred)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject a
cred
Int32
result <- (FunPtr C_CredAcquireCallback -> C_CredAcquireCallback
__dynamic_C_CredAcquireCallback FunPtr C_CredAcquireCallback
__funPtr) CString
url' CString
maybeUsernameFromUrl Word32
allowedTypes Ptr Cred
cred' Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cred
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
url'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeUsernameFromUrl
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback)
type CredAcquireCallback =
T.Text
-> Maybe T.Text
-> Word32
-> Ggit.Cred.Cred
-> IO Int32
noCredAcquireCallback :: Maybe CredAcquireCallback
noCredAcquireCallback :: Maybe CredAcquireCallback
noCredAcquireCallback = Maybe CredAcquireCallback
forall a. Maybe a
Nothing
type CredAcquireCallback_WithClosures =
T.Text
-> Maybe T.Text
-> Word32
-> Ggit.Cred.Cred
-> Ptr ()
-> IO Int32
noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures
noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures
noCredAcquireCallback_WithClosures = Maybe CredAcquireCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures
drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures
drop_closures_CredAcquireCallback CredAcquireCallback
_f Text
url Maybe Text
usernameFromUrl Word32
allowedTypes Cred
cred Ptr ()
_ = CredAcquireCallback
_f Text
url Maybe Text
usernameFromUrl Word32
allowedTypes Cred
cred
genClosure_CredAcquireCallback :: MonadIO m => CredAcquireCallback -> m (GClosure C_CredAcquireCallback)
genClosure_CredAcquireCallback :: CredAcquireCallback -> m (GClosure C_CredAcquireCallback)
genClosure_CredAcquireCallback CredAcquireCallback
cb = IO (GClosure C_CredAcquireCallback)
-> m (GClosure C_CredAcquireCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CredAcquireCallback)
-> m (GClosure C_CredAcquireCallback))
-> IO (GClosure C_CredAcquireCallback)
-> m (GClosure C_CredAcquireCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CredAcquireCallback_WithClosures
cb' = CredAcquireCallback -> CredAcquireCallback_WithClosures
drop_closures_CredAcquireCallback CredAcquireCallback
cb
let cb'' :: C_CredAcquireCallback
cb'' = Maybe (Ptr (FunPtr C_CredAcquireCallback))
-> CredAcquireCallback_WithClosures -> C_CredAcquireCallback
wrap_CredAcquireCallback Maybe (Ptr (FunPtr C_CredAcquireCallback))
forall a. Maybe a
Nothing CredAcquireCallback_WithClosures
cb'
C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback)
mk_CredAcquireCallback C_CredAcquireCallback
cb'' IO (FunPtr C_CredAcquireCallback)
-> (FunPtr C_CredAcquireCallback
-> IO (GClosure C_CredAcquireCallback))
-> IO (GClosure C_CredAcquireCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CredAcquireCallback -> IO (GClosure C_CredAcquireCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CredAcquireCallback ::
Maybe (Ptr (FunPtr C_CredAcquireCallback)) ->
CredAcquireCallback_WithClosures ->
C_CredAcquireCallback
wrap_CredAcquireCallback :: Maybe (Ptr (FunPtr C_CredAcquireCallback))
-> CredAcquireCallback_WithClosures -> C_CredAcquireCallback
wrap_CredAcquireCallback Maybe (Ptr (FunPtr C_CredAcquireCallback))
funptrptr CredAcquireCallback_WithClosures
_cb CString
url CString
usernameFromUrl Word32
allowedTypes Ptr Cred
cred Ptr ()
userData = do
Text
url' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
url
Maybe Text
maybeUsernameFromUrl <-
if CString
usernameFromUrl CString -> CString -> Bool
forall a. Eq a => a -> a -> Bool
== CString
forall a. Ptr a
nullPtr
then Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
else do
Text
usernameFromUrl' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
usernameFromUrl
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text -> IO (Maybe Text)) -> Maybe Text -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
usernameFromUrl'
Cred
cred' <- ((ManagedPtr Cred -> Cred) -> Ptr Cred -> IO Cred
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Cred -> Cred
Ggit.Cred.Cred) Ptr Cred
cred
Int32
result <- CredAcquireCallback_WithClosures
_cb Text
url' Maybe Text
maybeUsernameFromUrl Word32
allowedTypes Cred
cred' Ptr ()
userData
Maybe (Ptr (FunPtr C_CredAcquireCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CredAcquireCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_ConfigMatchCallback =
Ptr GLib.MatchInfo.MatchInfo ->
CString ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_ConfigMatchCallback :: FunPtr C_ConfigMatchCallback -> C_ConfigMatchCallback
dynamic_ConfigMatchCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ConfigMatchCallback
-> GLib.MatchInfo.MatchInfo
-> T.Text
-> Ptr ()
-> m Int32
dynamic_ConfigMatchCallback :: FunPtr C_ConfigMatchCallback
-> MatchInfo -> Text -> Ptr () -> m Int32
dynamic_ConfigMatchCallback FunPtr C_ConfigMatchCallback
__funPtr MatchInfo
matchInfo Text
value Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr MatchInfo
matchInfo' <- MatchInfo -> IO (Ptr MatchInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MatchInfo
matchInfo
CString
value' <- Text -> IO CString
textToCString Text
value
Int32
result <- (FunPtr C_ConfigMatchCallback -> C_ConfigMatchCallback
__dynamic_C_ConfigMatchCallback FunPtr C_ConfigMatchCallback
__funPtr) Ptr MatchInfo
matchInfo' CString
value' Ptr ()
userData
MatchInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MatchInfo
matchInfo
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback)
type ConfigMatchCallback =
GLib.MatchInfo.MatchInfo
-> T.Text
-> IO Int32
noConfigMatchCallback :: Maybe ConfigMatchCallback
noConfigMatchCallback :: Maybe ConfigMatchCallback
noConfigMatchCallback = Maybe ConfigMatchCallback
forall a. Maybe a
Nothing
type ConfigMatchCallback_WithClosures =
GLib.MatchInfo.MatchInfo
-> T.Text
-> Ptr ()
-> IO Int32
noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures
noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures
noConfigMatchCallback_WithClosures = Maybe ConfigMatchCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures
drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures
drop_closures_ConfigMatchCallback ConfigMatchCallback
_f MatchInfo
matchInfo Text
value Ptr ()
_ = ConfigMatchCallback
_f MatchInfo
matchInfo Text
value
genClosure_ConfigMatchCallback :: MonadIO m => ConfigMatchCallback -> m (GClosure C_ConfigMatchCallback)
genClosure_ConfigMatchCallback :: ConfigMatchCallback -> m (GClosure C_ConfigMatchCallback)
genClosure_ConfigMatchCallback ConfigMatchCallback
cb = IO (GClosure C_ConfigMatchCallback)
-> m (GClosure C_ConfigMatchCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ConfigMatchCallback)
-> m (GClosure C_ConfigMatchCallback))
-> IO (GClosure C_ConfigMatchCallback)
-> m (GClosure C_ConfigMatchCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ConfigMatchCallback_WithClosures
cb' = ConfigMatchCallback -> ConfigMatchCallback_WithClosures
drop_closures_ConfigMatchCallback ConfigMatchCallback
cb
let cb'' :: C_ConfigMatchCallback
cb'' = Maybe (Ptr (FunPtr C_ConfigMatchCallback))
-> ConfigMatchCallback_WithClosures -> C_ConfigMatchCallback
wrap_ConfigMatchCallback Maybe (Ptr (FunPtr C_ConfigMatchCallback))
forall a. Maybe a
Nothing ConfigMatchCallback_WithClosures
cb'
C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback)
mk_ConfigMatchCallback C_ConfigMatchCallback
cb'' IO (FunPtr C_ConfigMatchCallback)
-> (FunPtr C_ConfigMatchCallback
-> IO (GClosure C_ConfigMatchCallback))
-> IO (GClosure C_ConfigMatchCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ConfigMatchCallback -> IO (GClosure C_ConfigMatchCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ConfigMatchCallback ::
Maybe (Ptr (FunPtr C_ConfigMatchCallback)) ->
ConfigMatchCallback_WithClosures ->
C_ConfigMatchCallback
wrap_ConfigMatchCallback :: Maybe (Ptr (FunPtr C_ConfigMatchCallback))
-> ConfigMatchCallback_WithClosures -> C_ConfigMatchCallback
wrap_ConfigMatchCallback Maybe (Ptr (FunPtr C_ConfigMatchCallback))
funptrptr ConfigMatchCallback_WithClosures
_cb Ptr MatchInfo
matchInfo CString
value Ptr ()
userData = do
(ManagedPtr MatchInfo -> MatchInfo)
-> Ptr MatchInfo -> (MatchInfo -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr MatchInfo -> MatchInfo
GLib.MatchInfo.MatchInfo Ptr MatchInfo
matchInfo ((MatchInfo -> IO Int32) -> IO Int32)
-> (MatchInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \MatchInfo
matchInfo' -> do
Text
value' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value
Int32
result <- ConfigMatchCallback_WithClosures
_cb MatchInfo
matchInfo' Text
value' Ptr ()
userData
Maybe (Ptr (FunPtr C_ConfigMatchCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ConfigMatchCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_ConfigCallback =
Ptr Ggit.ConfigEntry.ConfigEntry ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_ConfigCallback :: FunPtr C_ConfigCallback -> C_ConfigCallback
dynamic_ConfigCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ConfigCallback
-> Ggit.ConfigEntry.ConfigEntry
-> Ptr ()
-> m Int32
dynamic_ConfigCallback :: FunPtr C_ConfigCallback -> ConfigEntry -> Ptr () -> m Int32
dynamic_ConfigCallback FunPtr C_ConfigCallback
__funPtr ConfigEntry
entry Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
Int32
result <- (FunPtr C_ConfigCallback -> C_ConfigCallback
__dynamic_C_ConfigCallback FunPtr C_ConfigCallback
__funPtr) Ptr ConfigEntry
entry' Ptr ()
userData
ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback)
type ConfigCallback =
Ggit.ConfigEntry.ConfigEntry
-> IO Int32
noConfigCallback :: Maybe ConfigCallback
noConfigCallback :: Maybe ConfigCallback
noConfigCallback = Maybe ConfigCallback
forall a. Maybe a
Nothing
type ConfigCallback_WithClosures =
Ggit.ConfigEntry.ConfigEntry
-> Ptr ()
-> IO Int32
noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures
noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures
noConfigCallback_WithClosures = Maybe ConfigCallback_WithClosures
forall a. Maybe a
Nothing
drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures
drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures
drop_closures_ConfigCallback ConfigCallback
_f ConfigEntry
entry Ptr ()
_ = ConfigCallback
_f ConfigEntry
entry
genClosure_ConfigCallback :: MonadIO m => ConfigCallback -> m (GClosure C_ConfigCallback)
genClosure_ConfigCallback :: ConfigCallback -> m (GClosure C_ConfigCallback)
genClosure_ConfigCallback ConfigCallback
cb = IO (GClosure C_ConfigCallback) -> m (GClosure C_ConfigCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ConfigCallback) -> m (GClosure C_ConfigCallback))
-> IO (GClosure C_ConfigCallback) -> m (GClosure C_ConfigCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ConfigCallback_WithClosures
cb' = ConfigCallback -> ConfigCallback_WithClosures
drop_closures_ConfigCallback ConfigCallback
cb
let cb'' :: C_ConfigCallback
cb'' = Maybe (Ptr (FunPtr C_ConfigCallback))
-> ConfigCallback_WithClosures -> C_ConfigCallback
wrap_ConfigCallback Maybe (Ptr (FunPtr C_ConfigCallback))
forall a. Maybe a
Nothing ConfigCallback_WithClosures
cb'
C_ConfigCallback -> IO (FunPtr C_ConfigCallback)
mk_ConfigCallback C_ConfigCallback
cb'' IO (FunPtr C_ConfigCallback)
-> (FunPtr C_ConfigCallback -> IO (GClosure C_ConfigCallback))
-> IO (GClosure C_ConfigCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ConfigCallback -> IO (GClosure C_ConfigCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ConfigCallback ::
Maybe (Ptr (FunPtr C_ConfigCallback)) ->
ConfigCallback_WithClosures ->
C_ConfigCallback
wrap_ConfigCallback :: Maybe (Ptr (FunPtr C_ConfigCallback))
-> ConfigCallback_WithClosures -> C_ConfigCallback
wrap_ConfigCallback Maybe (Ptr (FunPtr C_ConfigCallback))
funptrptr ConfigCallback_WithClosures
_cb Ptr ConfigEntry
entry Ptr ()
userData = do
(ManagedPtr ConfigEntry -> ConfigEntry)
-> Ptr ConfigEntry -> ConfigCallback -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr ConfigEntry -> ConfigEntry
Ggit.ConfigEntry.ConfigEntry Ptr ConfigEntry
entry (ConfigCallback -> IO Int32) -> ConfigCallback -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ConfigEntry
entry' -> do
Int32
result <- ConfigCallback_WithClosures
_cb ConfigEntry
entry' Ptr ()
userData
Maybe (Ptr (FunPtr C_ConfigCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ConfigCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result