{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a rebase object.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Ggit.Objects.Rebase
    (

-- * Exported types
    Rebase(..)                              ,
    IsRebase                                ,
    toRebase                                ,
    noRebase                                ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveRebaseMethod                     ,
#endif


-- ** abort #method:abort#

#if defined(ENABLE_OVERLOADING)
    RebaseAbortMethodInfo                   ,
#endif
    rebaseAbort                             ,


-- ** commit #method:commit#

#if defined(ENABLE_OVERLOADING)
    RebaseCommitMethodInfo                  ,
#endif
    rebaseCommit                            ,


-- ** finish #method:finish#

#if defined(ENABLE_OVERLOADING)
    RebaseFinishMethodInfo                  ,
#endif
    rebaseFinish                            ,


-- ** getOperationByIndex #method:getOperationByIndex#

#if defined(ENABLE_OVERLOADING)
    RebaseGetOperationByIndexMethodInfo     ,
#endif
    rebaseGetOperationByIndex               ,


-- ** getOperationEntryCount #method:getOperationEntryCount#

#if defined(ENABLE_OVERLOADING)
    RebaseGetOperationEntryCountMethodInfo  ,
#endif
    rebaseGetOperationEntryCount            ,


-- ** getOperationIndex #method:getOperationIndex#

#if defined(ENABLE_OVERLOADING)
    RebaseGetOperationIndexMethodInfo       ,
#endif
    rebaseGetOperationIndex                 ,


-- ** next #method:next#

#if defined(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.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.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

-- | Memory-managed wrapper type.
newtype Rebase = Rebase (ManagedPtr Rebase)
    deriving (Eq)
foreign import ccall "ggit_rebase_get_type"
    c_ggit_rebase_get_type :: IO GType

instance GObject Rebase where
    gobjectType = c_ggit_rebase_get_type


-- | Convert 'Rebase' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Rebase where
    toGValue o = do
        gtype <- c_ggit_rebase_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 Rebase)
        B.ManagedPtr.newObject Rebase ptr



-- | Type class for types which can be safely cast to `Rebase`, for instance with `toRebase`.
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]

-- | Cast to `Rebase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toRebase :: (MonadIO m, IsRebase o) => o -> m Rebase
toRebase = liftIO . unsafeCastTo Rebase

-- | A convenience alias for `Nothing` :: `Maybe` `Rebase`.
noRebase :: Maybe Rebase
noRebase = Nothing

#if defined(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 @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Rebase
type instance O.AttributeList Rebase = RebaseAttributeList
type RebaseAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Rebase = RebaseSignalList
type RebaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Rebase::abort
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : True
-- Skip return : False

foreign import ccall "ggit_rebase_abort" ggit_rebase_abort ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

-- | Aborts a rebase that is currently in progress, resetting the repository
-- and working directory to their state before rebase began.
rebaseAbort ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
rebaseAbort rebase = liftIO $ do
    rebase' <- unsafeManagedPtrCastPtr rebase
    onException (do
        propagateGError $ ggit_rebase_abort rebase'
        touchManagedPtr rebase
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data RebaseAbortMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRebase a) => O.MethodInfo RebaseAbortMethodInfo a signature where
    overloadedMethod = rebaseAbort

#endif

-- method Rebase::commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "author"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Signature" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GgitSignature or %NULL to keep the author from\nthe original commit."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "committer"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Signature" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitSignature." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "message"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the message for this commit, or %NULL to use\nthe message from the original commit."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Ggit" , name = "OId" })
-- throws : True
-- Skip return : False

foreign import ccall "ggit_rebase_commit" ggit_rebase_commit ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    Ptr Ggit.Signature.Signature ->         -- author : TInterface (Name {namespace = "Ggit", name = "Signature"})
    Ptr Ggit.Signature.Signature ->         -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"})
    CString ->                              -- message : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.OId.OId)

-- | Commits the current patch.  You must have resolved any conflicts that
-- were introduced during the patch application from the 'GI.Ggit.Objects.Rebase.rebaseNext'
-- invocation.
rebaseCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> Maybe (b)
    -- ^ /@author@/: a t'GI.Ggit.Objects.Signature.Signature' or 'P.Nothing' to keep the author from
    -- the original commit.
    -> c
    -- ^ /@committer@/: a t'GI.Ggit.Objects.Signature.Signature'.
    -> Maybe (T.Text)
    -- ^ /@message@/: the message for this commit, or 'P.Nothing' to use
    -- the message from the original commit.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.OId.OId' of the newly created commit or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
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 defined(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

-- method Rebase::finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signature"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Signature" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the identity that is finishing the rebase or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : True
-- Skip return : False

foreign import ccall "ggit_rebase_finish" ggit_rebase_finish ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    Ptr Ggit.Signature.Signature ->         -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

-- | Finishes a rebase that is currently in progress once all patches have
-- been applied.
rebaseFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> Maybe (b)
    -- ^ /@signature@/: the identity that is finishing the rebase or 'P.Nothing'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
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 defined(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

-- method Rebase::get_operation_by_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The index of the rebase operation to retrieve."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "RebaseOperation" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_get_operation_by_index" ggit_rebase_get_operation_by_index ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    Word32 ->                               -- idx : TBasicType TUInt32
    IO (Ptr Ggit.RebaseOperation.RebaseOperation)

-- | Gets the rebase operation specified by /@idx@/.
rebaseGetOperationByIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> Word32
    -- ^ /@idx@/: The index of the rebase operation to retrieve.
    -> m (Maybe Ggit.RebaseOperation.RebaseOperation)
    -- ^ __Returns:__ The rebase operation or 'P.Nothing' if /@idx@/ was out of bounds.
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 defined(ENABLE_OVERLOADING)
data RebaseGetOperationByIndexMethodInfo
instance (signature ~ (Word32 -> m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationByIndexMethodInfo a signature where
    overloadedMethod = rebaseGetOperationByIndex

#endif

-- method Rebase::get_operation_entry_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_get_operation_entry_count" ggit_rebase_get_operation_entry_count ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    IO Word32

-- | Gets the count of rebase operations that are to be applied.
rebaseGetOperationEntryCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> m Word32
    -- ^ __Returns:__ the count of rebase operations that are to be applied.
rebaseGetOperationEntryCount rebase = liftIO $ do
    rebase' <- unsafeManagedPtrCastPtr rebase
    result <- ggit_rebase_get_operation_entry_count rebase'
    touchManagedPtr rebase
    return result

#if defined(ENABLE_OVERLOADING)
data RebaseGetOperationEntryCountMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationEntryCountMethodInfo a signature where
    overloadedMethod = rebaseGetOperationEntryCount

#endif

-- method Rebase::get_operation_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_rebase_get_operation_index" ggit_rebase_get_operation_index ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    IO Word32

-- | Gets the index of the rebase operation that is currently being applied.
-- If the first operation has not yet been applied (because you have
-- called 'GI.Ggit.Objects.Repository.repositoryRebaseInit' but not yet 'GI.Ggit.Objects.Rebase.rebaseNext')
-- then this returns /@gGITREBASENOOPERATION@/.
rebaseGetOperationIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> m Word32
    -- ^ __Returns:__ The index of the rebase operation currently being applied.
rebaseGetOperationIndex rebase = liftIO $ do
    rebase' <- unsafeManagedPtrCastPtr rebase
    result <- ggit_rebase_get_operation_index rebase'
    touchManagedPtr rebase
    return result

#if defined(ENABLE_OVERLOADING)
data RebaseGetOperationIndexMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationIndexMethodInfo a signature where
    overloadedMethod = rebaseGetOperationIndex

#endif

-- method Rebase::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rebase"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "Rebase" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitRebase." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "RebaseOperation" })
-- throws : True
-- Skip return : False

foreign import ccall "ggit_rebase_next" ggit_rebase_next ::
    Ptr Rebase ->                           -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.RebaseOperation.RebaseOperation)

-- | Performs the next rebase operation and returns the information about it.
-- If the operation is one that applies a patch (which is any operation except
-- /@gGITREBASEOPERATIONEXEC@/) then the patch will be applied and the index and
-- working directory will be updated with the changes. If there are conflicts,
-- you will need to address those before committing the changes.
rebaseNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsRebase a) =>
    a
    -- ^ /@rebase@/: a t'GI.Ggit.Objects.Rebase.Rebase'.
    -> m (Maybe Ggit.RebaseOperation.RebaseOperation)
    -- ^ __Returns:__ the rebase operation that is to be performed next or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
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 defined(ENABLE_OVERLOADING)
data RebaseNextMethodInfo
instance (signature ~ (m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseNextMethodInfo a signature where
    overloadedMethod = rebaseNext

#endif