{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.RevisionWalker
(
RevisionWalker(..) ,
IsRevisionWalker ,
toRevisionWalker ,
noRevisionWalker ,
#if defined(ENABLE_OVERLOADING)
ResolveRevisionWalkerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RevisionWalkerGetRepositoryMethodInfo ,
#endif
revisionWalkerGetRepository ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerHideMethodInfo ,
#endif
revisionWalkerHide ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerHideGlobMethodInfo ,
#endif
revisionWalkerHideGlob ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerHideHeadMethodInfo ,
#endif
revisionWalkerHideHead ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerHideRefMethodInfo ,
#endif
revisionWalkerHideRef ,
revisionWalkerNew ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerNextMethodInfo ,
#endif
revisionWalkerNext ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerPushMethodInfo ,
#endif
revisionWalkerPush ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerPushGlobMethodInfo ,
#endif
revisionWalkerPushGlob ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerPushHeadMethodInfo ,
#endif
revisionWalkerPushHead ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerPushRangeMethodInfo ,
#endif
revisionWalkerPushRange ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerPushRefMethodInfo ,
#endif
revisionWalkerPushRef ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerResetMethodInfo ,
#endif
revisionWalkerReset ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerSetSortModeMethodInfo ,
#endif
revisionWalkerSetSortMode ,
#if defined(ENABLE_OVERLOADING)
RevisionWalkerRepositoryPropertyInfo ,
#endif
clearRevisionWalkerRepository ,
constructRevisionWalkerRepository ,
getRevisionWalkerRepository ,
#if defined(ENABLE_OVERLOADING)
revisionWalkerRepository ,
#endif
setRevisionWalkerRepository ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
newtype RevisionWalker = RevisionWalker (ManagedPtr RevisionWalker)
deriving (Eq)
foreign import ccall "ggit_revision_walker_get_type"
c_ggit_revision_walker_get_type :: IO GType
instance GObject RevisionWalker where
gobjectType = c_ggit_revision_walker_get_type
instance B.GValue.IsGValue RevisionWalker where
toGValue o = do
gtype <- c_ggit_revision_walker_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr RevisionWalker)
B.ManagedPtr.newObject RevisionWalker ptr
class (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o
instance (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o
instance O.HasParentTypes RevisionWalker
type instance O.ParentTypes RevisionWalker = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable]
toRevisionWalker :: (MonadIO m, IsRevisionWalker o) => o -> m RevisionWalker
toRevisionWalker = liftIO . unsafeCastTo RevisionWalker
noRevisionWalker :: Maybe RevisionWalker
noRevisionWalker = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveRevisionWalkerMethod (t :: Symbol) (o :: *) :: * where
ResolveRevisionWalkerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRevisionWalkerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRevisionWalkerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRevisionWalkerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRevisionWalkerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRevisionWalkerMethod "hide" o = RevisionWalkerHideMethodInfo
ResolveRevisionWalkerMethod "hideGlob" o = RevisionWalkerHideGlobMethodInfo
ResolveRevisionWalkerMethod "hideHead" o = RevisionWalkerHideHeadMethodInfo
ResolveRevisionWalkerMethod "hideRef" o = RevisionWalkerHideRefMethodInfo
ResolveRevisionWalkerMethod "init" o = Gio.Initable.InitableInitMethodInfo
ResolveRevisionWalkerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRevisionWalkerMethod "next" o = RevisionWalkerNextMethodInfo
ResolveRevisionWalkerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRevisionWalkerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRevisionWalkerMethod "push" o = RevisionWalkerPushMethodInfo
ResolveRevisionWalkerMethod "pushGlob" o = RevisionWalkerPushGlobMethodInfo
ResolveRevisionWalkerMethod "pushHead" o = RevisionWalkerPushHeadMethodInfo
ResolveRevisionWalkerMethod "pushRange" o = RevisionWalkerPushRangeMethodInfo
ResolveRevisionWalkerMethod "pushRef" o = RevisionWalkerPushRefMethodInfo
ResolveRevisionWalkerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRevisionWalkerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRevisionWalkerMethod "reset" o = RevisionWalkerResetMethodInfo
ResolveRevisionWalkerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRevisionWalkerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRevisionWalkerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRevisionWalkerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRevisionWalkerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRevisionWalkerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRevisionWalkerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRevisionWalkerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRevisionWalkerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRevisionWalkerMethod "getRepository" o = RevisionWalkerGetRepositoryMethodInfo
ResolveRevisionWalkerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRevisionWalkerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRevisionWalkerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRevisionWalkerMethod "setSortMode" o = RevisionWalkerSetSortModeMethodInfo
ResolveRevisionWalkerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRevisionWalkerMethod t RevisionWalker, O.MethodInfo info RevisionWalker p) => OL.IsLabel t (RevisionWalker -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m (Maybe Ggit.Repository.Repository)
getRevisionWalkerRepository obj = liftIO $ B.Properties.getObjectPropertyObject obj "repository" Ggit.Repository.Repository
setRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o, Ggit.Repository.IsRepository a) => o -> a -> m ()
setRevisionWalkerRepository obj val = liftIO $ B.Properties.setObjectPropertyObject obj "repository" (Just val)
constructRevisionWalkerRepository :: (IsRevisionWalker o, Ggit.Repository.IsRepository a) => a -> IO (GValueConstruct o)
constructRevisionWalkerRepository val = B.Properties.constructObjectPropertyObject "repository" (Just val)
clearRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m ()
clearRevisionWalkerRepository obj = liftIO $ B.Properties.setObjectPropertyObject obj "repository" (Nothing :: Maybe Ggit.Repository.Repository)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerRepositoryPropertyInfo
instance AttrInfo RevisionWalkerRepositoryPropertyInfo where
type AttrAllowedOps RevisionWalkerRepositoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint RevisionWalkerRepositoryPropertyInfo = IsRevisionWalker
type AttrSetTypeConstraint RevisionWalkerRepositoryPropertyInfo = Ggit.Repository.IsRepository
type AttrTransferTypeConstraint RevisionWalkerRepositoryPropertyInfo = Ggit.Repository.IsRepository
type AttrTransferType RevisionWalkerRepositoryPropertyInfo = Ggit.Repository.Repository
type AttrGetType RevisionWalkerRepositoryPropertyInfo = (Maybe Ggit.Repository.Repository)
type AttrLabel RevisionWalkerRepositoryPropertyInfo = "repository"
type AttrOrigin RevisionWalkerRepositoryPropertyInfo = RevisionWalker
attrGet = getRevisionWalkerRepository
attrSet = setRevisionWalkerRepository
attrTransfer _ v = do
unsafeCastTo Ggit.Repository.Repository v
attrConstruct = constructRevisionWalkerRepository
attrClear = clearRevisionWalkerRepository
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RevisionWalker
type instance O.AttributeList RevisionWalker = RevisionWalkerAttributeList
type RevisionWalkerAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("repository", RevisionWalkerRepositoryPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
revisionWalkerRepository :: AttrLabelProxy "repository"
revisionWalkerRepository = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList RevisionWalker = RevisionWalkerSignalList
type RevisionWalkerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_revision_walker_new" ggit_revision_walker_new ::
Ptr Ggit.Repository.Repository ->
Ptr (Ptr GError) ->
IO (Ptr RevisionWalker)
revisionWalkerNew ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a) =>
a
-> m (Maybe RevisionWalker)
revisionWalkerNew repository = liftIO $ do
repository' <- unsafeManagedPtrCastPtr repository
onException (do
result <- propagateGError $ ggit_revision_walker_new repository'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject RevisionWalker) result'
return result''
touchManagedPtr repository
return maybeResult
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_revision_walker_get_repository" ggit_revision_walker_get_repository ::
Ptr RevisionWalker ->
IO (Ptr Ggit.Repository.Repository)
revisionWalkerGetRepository ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> m (Maybe Ggit.Repository.Repository)
revisionWalkerGetRepository walker = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
result <- ggit_revision_walker_get_repository walker'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Ggit.Repository.Repository) result'
return result''
touchManagedPtr walker
return maybeResult
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerGetRepositoryMethodInfo
instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerGetRepositoryMethodInfo a signature where
overloadedMethod = revisionWalkerGetRepository
#endif
foreign import ccall "ggit_revision_walker_hide" ggit_revision_walker_hide ::
Ptr RevisionWalker ->
Ptr Ggit.OId.OId ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerHide ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> Ggit.OId.OId
-> m ()
revisionWalkerHide walker oid = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
oid' <- unsafeManagedPtrGetPtr oid
onException (do
propagateGError $ ggit_revision_walker_hide walker' oid'
touchManagedPtr walker
touchManagedPtr oid
return ()
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerHideMethodInfo
instance (signature ~ (Ggit.OId.OId -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideMethodInfo a signature where
overloadedMethod = revisionWalkerHide
#endif
foreign import ccall "ggit_revision_walker_hide_glob" ggit_revision_walker_hide_glob ::
Ptr RevisionWalker ->
CString ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerHideGlob ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> T.Text
-> m ()
revisionWalkerHideGlob walker item = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
item' <- textToCString item
onException (do
propagateGError $ ggit_revision_walker_hide_glob walker' item'
touchManagedPtr walker
freeMem item'
return ()
) (do
freeMem item'
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerHideGlobMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideGlobMethodInfo a signature where
overloadedMethod = revisionWalkerHideGlob
#endif
foreign import ccall "ggit_revision_walker_hide_head" ggit_revision_walker_hide_head ::
Ptr RevisionWalker ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerHideHead ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> m ()
revisionWalkerHideHead walker = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
onException (do
propagateGError $ ggit_revision_walker_hide_head walker'
touchManagedPtr walker
return ()
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerHideHeadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideHeadMethodInfo a signature where
overloadedMethod = revisionWalkerHideHead
#endif
foreign import ccall "ggit_revision_walker_hide_ref" ggit_revision_walker_hide_ref ::
Ptr RevisionWalker ->
CString ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerHideRef ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> T.Text
-> m ()
revisionWalkerHideRef walker item = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
item' <- textToCString item
onException (do
propagateGError $ ggit_revision_walker_hide_ref walker' item'
touchManagedPtr walker
freeMem item'
return ()
) (do
freeMem item'
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerHideRefMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideRefMethodInfo a signature where
overloadedMethod = revisionWalkerHideRef
#endif
foreign import ccall "ggit_revision_walker_next" ggit_revision_walker_next ::
Ptr RevisionWalker ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
revisionWalkerNext ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> m (Maybe Ggit.OId.OId)
revisionWalkerNext walker = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
onException (do
result <- propagateGError $ ggit_revision_walker_next walker'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr walker
return maybeResult
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerNextMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerNextMethodInfo a signature where
overloadedMethod = revisionWalkerNext
#endif
foreign import ccall "ggit_revision_walker_push" ggit_revision_walker_push ::
Ptr RevisionWalker ->
Ptr Ggit.OId.OId ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerPush ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> Ggit.OId.OId
-> m ()
revisionWalkerPush walker oid = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
oid' <- unsafeManagedPtrGetPtr oid
onException (do
propagateGError $ ggit_revision_walker_push walker' oid'
touchManagedPtr walker
touchManagedPtr oid
return ()
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerPushMethodInfo
instance (signature ~ (Ggit.OId.OId -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushMethodInfo a signature where
overloadedMethod = revisionWalkerPush
#endif
foreign import ccall "ggit_revision_walker_push_glob" ggit_revision_walker_push_glob ::
Ptr RevisionWalker ->
CString ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerPushGlob ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> T.Text
-> m ()
revisionWalkerPushGlob walker item = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
item' <- textToCString item
onException (do
propagateGError $ ggit_revision_walker_push_glob walker' item'
touchManagedPtr walker
freeMem item'
return ()
) (do
freeMem item'
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerPushGlobMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushGlobMethodInfo a signature where
overloadedMethod = revisionWalkerPushGlob
#endif
foreign import ccall "ggit_revision_walker_push_head" ggit_revision_walker_push_head ::
Ptr RevisionWalker ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerPushHead ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> m ()
revisionWalkerPushHead walker = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
onException (do
propagateGError $ ggit_revision_walker_push_head walker'
touchManagedPtr walker
return ()
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerPushHeadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushHeadMethodInfo a signature where
overloadedMethod = revisionWalkerPushHead
#endif
foreign import ccall "ggit_revision_walker_push_range" ggit_revision_walker_push_range ::
Ptr RevisionWalker ->
CString ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerPushRange ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> T.Text
-> m ()
revisionWalkerPushRange walker range = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
range' <- textToCString range
onException (do
propagateGError $ ggit_revision_walker_push_range walker' range'
touchManagedPtr walker
freeMem range'
return ()
) (do
freeMem range'
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerPushRangeMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushRangeMethodInfo a signature where
overloadedMethod = revisionWalkerPushRange
#endif
foreign import ccall "ggit_revision_walker_push_ref" ggit_revision_walker_push_ref ::
Ptr RevisionWalker ->
CString ->
Ptr (Ptr GError) ->
IO ()
revisionWalkerPushRef ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> T.Text
-> m ()
revisionWalkerPushRef walker item = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
item' <- textToCString item
onException (do
propagateGError $ ggit_revision_walker_push_ref walker' item'
touchManagedPtr walker
freeMem item'
return ()
) (do
freeMem item'
)
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerPushRefMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushRefMethodInfo a signature where
overloadedMethod = revisionWalkerPushRef
#endif
foreign import ccall "ggit_revision_walker_reset" ggit_revision_walker_reset ::
Ptr RevisionWalker ->
IO ()
revisionWalkerReset ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> m ()
revisionWalkerReset walker = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
ggit_revision_walker_reset walker'
touchManagedPtr walker
return ()
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerResetMethodInfo a signature where
overloadedMethod = revisionWalkerReset
#endif
foreign import ccall "ggit_revision_walker_set_sort_mode" ggit_revision_walker_set_sort_mode ::
Ptr RevisionWalker ->
CUInt ->
IO ()
revisionWalkerSetSortMode ::
(B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) =>
a
-> [Ggit.Flags.SortMode]
-> m ()
revisionWalkerSetSortMode walker sortMode = liftIO $ do
walker' <- unsafeManagedPtrCastPtr walker
let sortMode' = gflagsToWord sortMode
ggit_revision_walker_set_sort_mode walker' sortMode'
touchManagedPtr walker
return ()
#if defined(ENABLE_OVERLOADING)
data RevisionWalkerSetSortModeMethodInfo
instance (signature ~ ([Ggit.Flags.SortMode] -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerSetSortModeMethodInfo a signature where
overloadedMethod = revisionWalkerSetSortMode
#endif