#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Ggit.Objects.Rebase
(
Rebase(..) ,
IsRebase ,
toRebase ,
noRebase ,
#if ENABLE_OVERLOADING
RebaseAbortMethodInfo ,
#endif
rebaseAbort ,
#if ENABLE_OVERLOADING
RebaseCommitMethodInfo ,
#endif
rebaseCommit ,
#if ENABLE_OVERLOADING
RebaseFinishMethodInfo ,
#endif
rebaseFinish ,
#if ENABLE_OVERLOADING
RebaseGetOperationByIndexMethodInfo ,
#endif
rebaseGetOperationByIndex ,
#if ENABLE_OVERLOADING
RebaseGetOperationEntryCountMethodInfo ,
#endif
rebaseGetOperationEntryCount ,
#if ENABLE_OVERLOADING
RebaseGetOperationIndexMethodInfo ,
#endif
rebaseGetOperationIndex ,
#if ENABLE_OVERLOADING
RebaseNextMethodInfo ,
#endif
rebaseNext ,
) 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.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.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.RebaseOperation as Ggit.RebaseOperation
newtype Rebase = Rebase (ManagedPtr Rebase)
foreign import ccall "ggit_rebase_get_type"
c_ggit_rebase_get_type :: IO GType
instance GObject Rebase where
gobjectType = c_ggit_rebase_get_type
class (GObject o, O.IsDescendantOf Rebase o) => IsRebase o
instance (GObject o, O.IsDescendantOf Rebase o) => IsRebase o
instance O.HasParentTypes Rebase
type instance O.ParentTypes Rebase = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]
toRebase :: (MonadIO m, IsRebase o) => o -> m Rebase
toRebase = liftIO . unsafeCastTo Rebase
noRebase :: Maybe Rebase
noRebase = Nothing
#if ENABLE_OVERLOADING
type family ResolveRebaseMethod (t :: Symbol) (o :: *) :: * where
ResolveRebaseMethod "abort" o = RebaseAbortMethodInfo
ResolveRebaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRebaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRebaseMethod "commit" o = RebaseCommitMethodInfo
ResolveRebaseMethod "finish" o = RebaseFinishMethodInfo
ResolveRebaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRebaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRebaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRebaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRebaseMethod "next" o = RebaseNextMethodInfo
ResolveRebaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRebaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRebaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRebaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRebaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRebaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRebaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRebaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRebaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRebaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRebaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRebaseMethod "getOperationByIndex" o = RebaseGetOperationByIndexMethodInfo
ResolveRebaseMethod "getOperationEntryCount" o = RebaseGetOperationEntryCountMethodInfo
ResolveRebaseMethod "getOperationIndex" o = RebaseGetOperationIndexMethodInfo
ResolveRebaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRebaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRebaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRebaseMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRebaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRebaseMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRebaseMethod t Rebase, O.MethodInfo info Rebase p) => OL.IsLabel t (Rebase -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Rebase
type instance O.AttributeList Rebase = RebaseAttributeList
type RebaseAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
type instance O.SignalList Rebase = RebaseSignalList
type RebaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_rebase_abort" ggit_rebase_abort ::
Ptr Rebase ->
Ptr (Ptr GError) ->
IO ()
rebaseAbort ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
a
-> m ()
rebaseAbort rebase = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
onException (do
propagateGError $ ggit_rebase_abort rebase'
touchManagedPtr rebase
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data RebaseAbortMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRebase a) => O.MethodInfo RebaseAbortMethodInfo a signature where
overloadedMethod _ = rebaseAbort
#endif
foreign import ccall "ggit_rebase_commit" ggit_rebase_commit ::
Ptr Rebase ->
Ptr Ggit.Signature.Signature ->
Ptr Ggit.Signature.Signature ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
rebaseCommit ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) =>
a
-> Maybe (b)
-> c
-> Maybe (T.Text)
-> m (Maybe Ggit.OId.OId)
rebaseCommit rebase author committer message = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
maybeAuthor <- case author of
Nothing -> return nullPtr
Just jAuthor -> do
jAuthor' <- unsafeManagedPtrCastPtr jAuthor
return jAuthor'
committer' <- unsafeManagedPtrCastPtr committer
maybeMessage <- case message of
Nothing -> return nullPtr
Just jMessage -> do
jMessage' <- textToCString jMessage
return jMessage'
onException (do
result <- propagateGError $ ggit_rebase_commit rebase' maybeAuthor committer' maybeMessage
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr rebase
whenJust author touchManagedPtr
touchManagedPtr committer
freeMem maybeMessage
return maybeResult
) (do
freeMem maybeMessage
)
#if ENABLE_OVERLOADING
data RebaseCommitMethodInfo
instance (signature ~ (Maybe (b) -> c -> Maybe (T.Text) -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRebase a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => O.MethodInfo RebaseCommitMethodInfo a signature where
overloadedMethod _ = rebaseCommit
#endif
foreign import ccall "ggit_rebase_finish" ggit_rebase_finish ::
Ptr Rebase ->
Ptr Ggit.Signature.Signature ->
Ptr (Ptr GError) ->
IO ()
rebaseFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b) =>
a
-> Maybe (b)
-> m ()
rebaseFinish rebase signature = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
maybeSignature <- case signature of
Nothing -> return nullPtr
Just jSignature -> do
jSignature' <- unsafeManagedPtrCastPtr jSignature
return jSignature'
onException (do
propagateGError $ ggit_rebase_finish rebase' maybeSignature
touchManagedPtr rebase
whenJust signature touchManagedPtr
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data RebaseFinishMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRebase a, Ggit.Signature.IsSignature b) => O.MethodInfo RebaseFinishMethodInfo a signature where
overloadedMethod _ = rebaseFinish
#endif
foreign import ccall "ggit_rebase_get_operation_by_index" ggit_rebase_get_operation_by_index ::
Ptr Rebase ->
Word64 ->
IO (Ptr Ggit.RebaseOperation.RebaseOperation)
rebaseGetOperationByIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
a
-> Word64
-> m (Maybe Ggit.RebaseOperation.RebaseOperation)
rebaseGetOperationByIndex rebase idx = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
result <- ggit_rebase_get_operation_by_index rebase' idx
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.RebaseOperation.RebaseOperation) result'
return result''
touchManagedPtr rebase
return maybeResult
#if ENABLE_OVERLOADING
data RebaseGetOperationByIndexMethodInfo
instance (signature ~ (Word64 -> m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationByIndexMethodInfo a signature where
overloadedMethod _ = rebaseGetOperationByIndex
#endif
foreign import ccall "ggit_rebase_get_operation_entry_count" ggit_rebase_get_operation_entry_count ::
Ptr Rebase ->
IO Word64
rebaseGetOperationEntryCount ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
a
-> m Word64
rebaseGetOperationEntryCount rebase = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
result <- ggit_rebase_get_operation_entry_count rebase'
touchManagedPtr rebase
return result
#if ENABLE_OVERLOADING
data RebaseGetOperationEntryCountMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationEntryCountMethodInfo a signature where
overloadedMethod _ = rebaseGetOperationEntryCount
#endif
foreign import ccall "ggit_rebase_get_operation_index" ggit_rebase_get_operation_index ::
Ptr Rebase ->
IO Word64
rebaseGetOperationIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
a
-> m Word64
rebaseGetOperationIndex rebase = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
result <- ggit_rebase_get_operation_index rebase'
touchManagedPtr rebase
return result
#if ENABLE_OVERLOADING
data RebaseGetOperationIndexMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationIndexMethodInfo a signature where
overloadedMethod _ = rebaseGetOperationIndex
#endif
foreign import ccall "ggit_rebase_next" ggit_rebase_next ::
Ptr Rebase ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.RebaseOperation.RebaseOperation)
rebaseNext ::
(B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
a
-> m (Maybe Ggit.RebaseOperation.RebaseOperation)
rebaseNext rebase = liftIO $ do
rebase' <- unsafeManagedPtrCastPtr rebase
onException (do
result <- propagateGError $ ggit_rebase_next rebase'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.RebaseOperation.RebaseOperation) result'
return result''
touchManagedPtr rebase
return maybeResult
) (do
return ()
)
#if ENABLE_OVERLOADING
data RebaseNextMethodInfo
instance (signature ~ (m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseNextMethodInfo a signature where
overloadedMethod _ = rebaseNext
#endif