{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

Represents blame options.
-}

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

module GI.Ggit.Structs.BlameOptions
    (

-- * Exported types
    BlameOptions(..)                        ,
    noBlameOptions                          ,


 -- * Methods
-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    BlameOptionsCopyMethodInfo              ,
#endif
    blameOptionsCopy                        ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    BlameOptionsFreeMethodInfo              ,
#endif
    blameOptionsFree                        ,


-- ** getMaximumLine #method:getMaximumLine#

#if ENABLE_OVERLOADING
    BlameOptionsGetMaximumLineMethodInfo    ,
#endif
    blameOptionsGetMaximumLine              ,


-- ** getMinimumLine #method:getMinimumLine#

#if ENABLE_OVERLOADING
    BlameOptionsGetMinimumLineMethodInfo    ,
#endif
    blameOptionsGetMinimumLine              ,


-- ** getMinimumMatchCharacters #method:getMinimumMatchCharacters#

#if ENABLE_OVERLOADING
    BlameOptionsGetMinimumMatchCharactersMethodInfo,
#endif
    blameOptionsGetMinimumMatchCharacters   ,


-- ** getNewestCommit #method:getNewestCommit#

#if ENABLE_OVERLOADING
    BlameOptionsGetNewestCommitMethodInfo   ,
#endif
    blameOptionsGetNewestCommit             ,


-- ** getOldestCommit #method:getOldestCommit#

#if ENABLE_OVERLOADING
    BlameOptionsGetOldestCommitMethodInfo   ,
#endif
    blameOptionsGetOldestCommit             ,


-- ** new #method:new#

    blameOptionsNew                         ,


-- ** setMaximumLine #method:setMaximumLine#

#if ENABLE_OVERLOADING
    BlameOptionsSetMaximumLineMethodInfo    ,
#endif
    blameOptionsSetMaximumLine              ,


-- ** setMinimumLine #method:setMinimumLine#

#if ENABLE_OVERLOADING
    BlameOptionsSetMinimumLineMethodInfo    ,
#endif
    blameOptionsSetMinimumLine              ,


-- ** setMinimumMatchCharacters #method:setMinimumMatchCharacters#

#if ENABLE_OVERLOADING
    BlameOptionsSetMinimumMatchCharactersMethodInfo,
#endif
    blameOptionsSetMinimumMatchCharacters   ,


-- ** setNewestCommit #method:setNewestCommit#

#if ENABLE_OVERLOADING
    BlameOptionsSetNewestCommitMethodInfo   ,
#endif
    blameOptionsSetNewestCommit             ,


-- ** setOldestCommit #method:setOldestCommit#

#if ENABLE_OVERLOADING
    BlameOptionsSetOldestCommitMethodInfo   ,
#endif
    blameOptionsSetOldestCommit             ,




    ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId

-- | Memory-managed wrapper type.
newtype BlameOptions = BlameOptions (ManagedPtr BlameOptions)
foreign import ccall "ggit_blame_options_get_type" c_ggit_blame_options_get_type ::
    IO GType

instance BoxedObject BlameOptions where
    boxedType _ = c_ggit_blame_options_get_type

-- | A convenience alias for `Nothing` :: `Maybe` `BlameOptions`.
noBlameOptions :: Maybe BlameOptions
noBlameOptions = Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList BlameOptions
type instance O.AttributeList BlameOptions = BlameOptionsAttributeList
type BlameOptionsAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method BlameOptions::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameOptions"}))
-- throws : False
-- Skip return : False

foreign import ccall "ggit_blame_options_new" ggit_blame_options_new ::
    IO (Ptr BlameOptions)

{- |
Create a new, empty 'GI.Ggit.Structs.BlameOptions.BlameOptions'.
-}
blameOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m BlameOptions
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
blameOptionsNew  = liftIO $ do
    result <- ggit_blame_options_new
    checkUnexpectedReturnNULL "blameOptionsNew" result
    result' <- (wrapBoxed BlameOptions) result
    return result'

#if ENABLE_OVERLOADING
#endif

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

foreign import ccall "ggit_blame_options_copy" ggit_blame_options_copy ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO (Ptr BlameOptions)

{- |
Copies /@blameOptions@/ into a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions'.
-}
blameOptionsCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m (Maybe BlameOptions)
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions' or 'Nothing'. -}
blameOptionsCopy blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_copy blameOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed BlameOptions) result'
        return result''
    touchManagedPtr blameOptions
    return maybeResult

#if ENABLE_OVERLOADING
data BlameOptionsCopyMethodInfo
instance (signature ~ (m (Maybe BlameOptions)), MonadIO m) => O.MethodInfo BlameOptionsCopyMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsCopy

#endif

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

foreign import ccall "ggit_blame_options_free" ggit_blame_options_free ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO ()

{- |
Frees /@blameOptions@/.
-}
blameOptionsFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m ()
blameOptionsFree blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    ggit_blame_options_free blameOptions'
    touchManagedPtr blameOptions
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BlameOptionsFreeMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsFree

#endif

-- method BlameOptions::get_maximum_line
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", 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_blame_options_get_maximum_line" ggit_blame_options_get_maximum_line ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO Word32

{- |
Get the last line in the file to consider. The default is 1.
-}
blameOptionsGetMaximumLine ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the last line to consider. -}
blameOptionsGetMaximumLine blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_get_maximum_line blameOptions'
    touchManagedPtr blameOptions
    return result

#if ENABLE_OVERLOADING
data BlameOptionsGetMaximumLineMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BlameOptionsGetMaximumLineMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsGetMaximumLine

#endif

-- method BlameOptions::get_minimum_line
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", 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_blame_options_get_minimum_line" ggit_blame_options_get_minimum_line ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO Word32

{- |
Get the first line in the file to consider. The default is 1.
-}
blameOptionsGetMinimumLine ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m Word32
    {- ^ __Returns:__ the first line to consider. -}
blameOptionsGetMinimumLine blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_get_minimum_line blameOptions'
    touchManagedPtr blameOptions
    return result

#if ENABLE_OVERLOADING
data BlameOptionsGetMinimumLineMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BlameOptionsGetMinimumLineMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsGetMinimumLine

#endif

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

foreign import ccall "ggit_blame_options_get_minimum_match_characters" ggit_blame_options_get_minimum_match_characters ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO Word16

{- |
Get the minimum number of characters that must be detected as moving\/copying
within a file for it to associate those lines with a parent commit. This is
only used when any of the @/GGIT_BLAME_TRACK_COPIES_SAME_FILE/@ flag is
specified. The default value is 20.
-}
blameOptionsGetMinimumMatchCharacters ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m Word16
    {- ^ __Returns:__ the minimum number of characters. -}
blameOptionsGetMinimumMatchCharacters blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_get_minimum_match_characters blameOptions'
    touchManagedPtr blameOptions
    return result

#if ENABLE_OVERLOADING
data BlameOptionsGetMinimumMatchCharactersMethodInfo
instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo BlameOptionsGetMinimumMatchCharactersMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsGetMinimumMatchCharacters

#endif

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

foreign import ccall "ggit_blame_options_get_newest_commit" ggit_blame_options_get_newest_commit ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO (Ptr Ggit.OId.OId)

{- |
Get the id of the newest commit to consider in the blame. The default
value of 'Nothing' indicates to use HEAD.
-}
blameOptionsGetNewestCommit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m (Maybe Ggit.OId.OId)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -}
blameOptionsGetNewestCommit blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_get_newest_commit blameOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr blameOptions
    return maybeResult

#if ENABLE_OVERLOADING
data BlameOptionsGetNewestCommitMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameOptionsGetNewestCommitMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsGetNewestCommit

#endif

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

foreign import ccall "ggit_blame_options_get_oldest_commit" ggit_blame_options_get_oldest_commit ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    IO (Ptr Ggit.OId.OId)

{- |
Get the id of the oldest commit to consider in the blame. Teh default value
of 'Nothing' indicates to used HEAD.
-}
blameOptionsGetOldestCommit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> m (Maybe Ggit.OId.OId)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -}
blameOptionsGetOldestCommit blameOptions = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    result <- ggit_blame_options_get_oldest_commit blameOptions'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr blameOptions
    return maybeResult

#if ENABLE_OVERLOADING
data BlameOptionsGetOldestCommitMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameOptionsGetOldestCommitMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsGetOldestCommit

#endif

-- method BlameOptions::set_maximum_line
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the last line to consider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_blame_options_set_maximum_line" ggit_blame_options_set_maximum_line ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    Word32 ->                               -- line : TBasicType TUInt32
    IO ()

{- |
Set the last line in the file to consider. Lines start at 1.
-}
blameOptionsSetMaximumLine ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> Word32
    {- ^ /@line@/: the last line to consider. -}
    -> m ()
blameOptionsSetMaximumLine blameOptions line = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    ggit_blame_options_set_maximum_line blameOptions' line
    touchManagedPtr blameOptions
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsSetMaximumLineMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMaximumLineMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsSetMaximumLine

#endif

-- method BlameOptions::set_minimum_line
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the first line to consider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_blame_options_set_minimum_line" ggit_blame_options_set_minimum_line ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    Word32 ->                               -- line : TBasicType TUInt32
    IO ()

{- |
Set the first line in the file to consider. Lines start at 1.
-}
blameOptionsSetMinimumLine ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> Word32
    {- ^ /@line@/: the first line to consider. -}
    -> m ()
blameOptionsSetMinimumLine blameOptions line = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    ggit_blame_options_set_minimum_line blameOptions' line
    touchManagedPtr blameOptions
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsSetMinimumLineMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMinimumLineMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsSetMinimumLine

#endif

-- method BlameOptions::set_minimum_match_characters
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "characters", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of characters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_blame_options_set_minimum_match_characters" ggit_blame_options_set_minimum_match_characters ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    Word16 ->                               -- characters : TBasicType TUInt16
    IO ()

{- |
Set the minimum number of characters that must be detected as moving\/copying
within a file for it to associate those lines with a parent commit. This is
only used when any of the @/GGIT_BLAME_TRACK_COPIES_/@ flags are specified. The
default value is 20.
-}
blameOptionsSetMinimumMatchCharacters ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> Word16
    {- ^ /@characters@/: the minimum number of characters. -}
    -> m ()
blameOptionsSetMinimumMatchCharacters blameOptions characters = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    ggit_blame_options_set_minimum_match_characters blameOptions' characters
    touchManagedPtr blameOptions
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsSetMinimumMatchCharactersMethodInfo
instance (signature ~ (Word16 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMinimumMatchCharactersMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsSetMinimumMatchCharacters

#endif

-- method BlameOptions::set_newest_commit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_blame_options_set_newest_commit" ggit_blame_options_set_newest_commit ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    Ptr Ggit.OId.OId ->                     -- oid : TInterface (Name {namespace = "Ggit", name = "OId"})
    IO ()

{- |
Set the id of the newest commit to consider in the blame. Specify 'Nothing' to
set the default value which indicates to use HEAD.
-}
blameOptionsSetNewestCommit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> Maybe (Ggit.OId.OId)
    {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -}
    -> m ()
blameOptionsSetNewestCommit blameOptions oid = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    maybeOid <- case oid of
        Nothing -> return nullPtr
        Just jOid -> do
            jOid' <- unsafeManagedPtrGetPtr jOid
            return jOid'
    ggit_blame_options_set_newest_commit blameOptions' maybeOid
    touchManagedPtr blameOptions
    whenJust oid touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsSetNewestCommitMethodInfo
instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetNewestCommitMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsSetNewestCommit

#endif

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

foreign import ccall "ggit_blame_options_set_oldest_commit" ggit_blame_options_set_oldest_commit ::
    Ptr BlameOptions ->                     -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"})
    Ptr Ggit.OId.OId ->                     -- oid : TInterface (Name {namespace = "Ggit", name = "OId"})
    IO ()

{- |
Set the id of the oldest commit to consider in the blame. Specify 'Nothing' to
set the default value which indicates to consider the first commit without
a parent.
-}
blameOptionsSetOldestCommit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BlameOptions
    {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -}
    -> Maybe (Ggit.OId.OId)
    {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -}
    -> m ()
blameOptionsSetOldestCommit blameOptions oid = liftIO $ do
    blameOptions' <- unsafeManagedPtrGetPtr blameOptions
    maybeOid <- case oid of
        Nothing -> return nullPtr
        Just jOid -> do
            jOid' <- unsafeManagedPtrGetPtr jOid
            return jOid'
    ggit_blame_options_set_oldest_commit blameOptions' maybeOid
    touchManagedPtr blameOptions
    whenJust oid touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data BlameOptionsSetOldestCommitMethodInfo
instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetOldestCommitMethodInfo BlameOptions signature where
    overloadedMethod _ = blameOptionsSetOldestCommit

#endif

#if ENABLE_OVERLOADING
type family ResolveBlameOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveBlameOptionsMethod "copy" o = BlameOptionsCopyMethodInfo
    ResolveBlameOptionsMethod "free" o = BlameOptionsFreeMethodInfo
    ResolveBlameOptionsMethod "getMaximumLine" o = BlameOptionsGetMaximumLineMethodInfo
    ResolveBlameOptionsMethod "getMinimumLine" o = BlameOptionsGetMinimumLineMethodInfo
    ResolveBlameOptionsMethod "getMinimumMatchCharacters" o = BlameOptionsGetMinimumMatchCharactersMethodInfo
    ResolveBlameOptionsMethod "getNewestCommit" o = BlameOptionsGetNewestCommitMethodInfo
    ResolveBlameOptionsMethod "getOldestCommit" o = BlameOptionsGetOldestCommitMethodInfo
    ResolveBlameOptionsMethod "setMaximumLine" o = BlameOptionsSetMaximumLineMethodInfo
    ResolveBlameOptionsMethod "setMinimumLine" o = BlameOptionsSetMinimumLineMethodInfo
    ResolveBlameOptionsMethod "setMinimumMatchCharacters" o = BlameOptionsSetMinimumMatchCharactersMethodInfo
    ResolveBlameOptionsMethod "setNewestCommit" o = BlameOptionsSetNewestCommitMethodInfo
    ResolveBlameOptionsMethod "setOldestCommit" o = BlameOptionsSetOldestCommitMethodInfo
    ResolveBlameOptionsMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBlameOptionsMethod t BlameOptions, O.MethodInfo info BlameOptions p) => OL.IsLabel t (BlameOptions -> 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