{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.DiffFindOptions
(
DiffFindOptions(..) ,
IsDiffFindOptions ,
toDiffFindOptions ,
#if defined(ENABLE_OVERLOADING)
ResolveDiffFindOptionsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetCopyThresholdMethodInfo,
#endif
diffFindOptionsGetCopyThreshold ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetFlagsMethodInfo ,
#endif
diffFindOptionsGetFlags ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetMetricMethodInfo ,
#endif
diffFindOptionsGetMetric ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo,
#endif
diffFindOptionsGetRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetRenameLimitMethodInfo ,
#endif
diffFindOptionsGetRenameLimit ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsGetRenameThresholdMethodInfo,
#endif
diffFindOptionsGetRenameThreshold ,
diffFindOptionsNew ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetCopyThresholdMethodInfo,
#endif
diffFindOptionsSetCopyThreshold ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetFlagsMethodInfo ,
#endif
diffFindOptionsSetFlags ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetMetricMethodInfo ,
#endif
diffFindOptionsSetMetric ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo,
#endif
diffFindOptionsSetRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetRenameLimitMethodInfo ,
#endif
diffFindOptionsSetRenameLimit ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsSetRenameThresholdMethodInfo,
#endif
diffFindOptionsSetRenameThreshold ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsCopyThresholdPropertyInfo,
#endif
constructDiffFindOptionsCopyThreshold ,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsCopyThreshold ,
#endif
getDiffFindOptionsCopyThreshold ,
setDiffFindOptionsCopyThreshold ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsFlagsPropertyInfo ,
#endif
constructDiffFindOptionsFlags ,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsFlags ,
#endif
getDiffFindOptionsFlags ,
setDiffFindOptionsFlags ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsMetricPropertyInfo ,
#endif
constructDiffFindOptionsMetric ,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsMetric ,
#endif
getDiffFindOptionsMetric ,
setDiffFindOptionsMetric ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsRenameFromRewriteThresholdPropertyInfo,
#endif
constructDiffFindOptionsRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsRenameFromRewriteThreshold,
#endif
getDiffFindOptionsRenameFromRewriteThreshold,
setDiffFindOptionsRenameFromRewriteThreshold,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsRenameLimitPropertyInfo ,
#endif
constructDiffFindOptionsRenameLimit ,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsRenameLimit ,
#endif
getDiffFindOptionsRenameLimit ,
setDiffFindOptionsRenameLimit ,
#if defined(ENABLE_OVERLOADING)
DiffFindOptionsRenameThresholdPropertyInfo,
#endif
constructDiffFindOptionsRenameThreshold ,
#if defined(ENABLE_OVERLOADING)
diffFindOptionsRenameThreshold ,
#endif
getDiffFindOptionsRenameThreshold ,
setDiffFindOptionsRenameThreshold ,
) 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.GArray as B.GArray
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.Coerce as Coerce
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 GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffSimilarityMetric as Ggit.DiffSimilarityMetric
newtype DiffFindOptions = DiffFindOptions (SP.ManagedPtr DiffFindOptions)
deriving (DiffFindOptions -> DiffFindOptions -> Bool
(DiffFindOptions -> DiffFindOptions -> Bool)
-> (DiffFindOptions -> DiffFindOptions -> Bool)
-> Eq DiffFindOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFindOptions -> DiffFindOptions -> Bool
$c/= :: DiffFindOptions -> DiffFindOptions -> Bool
== :: DiffFindOptions -> DiffFindOptions -> Bool
$c== :: DiffFindOptions -> DiffFindOptions -> Bool
Eq)
instance SP.ManagedPtrNewtype DiffFindOptions where
toManagedPtr :: DiffFindOptions -> ManagedPtr DiffFindOptions
toManagedPtr (DiffFindOptions ManagedPtr DiffFindOptions
p) = ManagedPtr DiffFindOptions
p
foreign import ccall "ggit_diff_find_options_get_type"
c_ggit_diff_find_options_get_type :: IO B.Types.GType
instance B.Types.TypedObject DiffFindOptions where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_find_options_get_type
instance B.Types.GObject DiffFindOptions
class (SP.GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o
instance (SP.GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o
instance O.HasParentTypes DiffFindOptions
type instance O.ParentTypes DiffFindOptions = '[GObject.Object.Object]
toDiffFindOptions :: (MIO.MonadIO m, IsDiffFindOptions o) => o -> m DiffFindOptions
toDiffFindOptions :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m DiffFindOptions
toDiffFindOptions = IO DiffFindOptions -> m DiffFindOptions
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DiffFindOptions -> m DiffFindOptions)
-> (o -> IO DiffFindOptions) -> o -> m DiffFindOptions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DiffFindOptions -> DiffFindOptions)
-> o -> IO DiffFindOptions
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DiffFindOptions -> DiffFindOptions
DiffFindOptions
instance B.GValue.IsGValue (Maybe DiffFindOptions) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_diff_find_options_get_type
gvalueSet_ :: Ptr GValue -> Maybe DiffFindOptions -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DiffFindOptions
P.Nothing = Ptr GValue -> Ptr DiffFindOptions -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DiffFindOptions
forall a. Ptr a
FP.nullPtr :: FP.Ptr DiffFindOptions)
gvalueSet_ Ptr GValue
gv (P.Just DiffFindOptions
obj) = DiffFindOptions -> (Ptr DiffFindOptions -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiffFindOptions
obj (Ptr GValue -> Ptr DiffFindOptions -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DiffFindOptions)
gvalueGet_ Ptr GValue
gv = do
Ptr DiffFindOptions
ptr <- Ptr GValue -> IO (Ptr DiffFindOptions)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DiffFindOptions)
if Ptr DiffFindOptions
ptr Ptr DiffFindOptions -> Ptr DiffFindOptions -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DiffFindOptions
forall a. Ptr a
FP.nullPtr
then DiffFindOptions -> Maybe DiffFindOptions
forall a. a -> Maybe a
P.Just (DiffFindOptions -> Maybe DiffFindOptions)
-> IO DiffFindOptions -> IO (Maybe DiffFindOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DiffFindOptions -> DiffFindOptions)
-> Ptr DiffFindOptions -> IO DiffFindOptions
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DiffFindOptions -> DiffFindOptions
DiffFindOptions Ptr DiffFindOptions
ptr
else Maybe DiffFindOptions -> IO (Maybe DiffFindOptions)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffFindOptions
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDiffFindOptionsMethod (t :: Symbol) (o :: *) :: * where
ResolveDiffFindOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDiffFindOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDiffFindOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDiffFindOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDiffFindOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDiffFindOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDiffFindOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDiffFindOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDiffFindOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDiffFindOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDiffFindOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDiffFindOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDiffFindOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDiffFindOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDiffFindOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDiffFindOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDiffFindOptionsMethod "getCopyThreshold" o = DiffFindOptionsGetCopyThresholdMethodInfo
ResolveDiffFindOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDiffFindOptionsMethod "getFlags" o = DiffFindOptionsGetFlagsMethodInfo
ResolveDiffFindOptionsMethod "getMetric" o = DiffFindOptionsGetMetricMethodInfo
ResolveDiffFindOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDiffFindOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDiffFindOptionsMethod "getRenameFromRewriteThreshold" o = DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo
ResolveDiffFindOptionsMethod "getRenameLimit" o = DiffFindOptionsGetRenameLimitMethodInfo
ResolveDiffFindOptionsMethod "getRenameThreshold" o = DiffFindOptionsGetRenameThresholdMethodInfo
ResolveDiffFindOptionsMethod "setCopyThreshold" o = DiffFindOptionsSetCopyThresholdMethodInfo
ResolveDiffFindOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDiffFindOptionsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDiffFindOptionsMethod "setFlags" o = DiffFindOptionsSetFlagsMethodInfo
ResolveDiffFindOptionsMethod "setMetric" o = DiffFindOptionsSetMetricMethodInfo
ResolveDiffFindOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDiffFindOptionsMethod "setRenameFromRewriteThreshold" o = DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo
ResolveDiffFindOptionsMethod "setRenameLimit" o = DiffFindOptionsSetRenameLimitMethodInfo
ResolveDiffFindOptionsMethod "setRenameThreshold" o = DiffFindOptionsSetRenameThresholdMethodInfo
ResolveDiffFindOptionsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiffFindOptionsMethod t DiffFindOptions, O.OverloadedMethod info DiffFindOptions p) => OL.IsLabel t (DiffFindOptions -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDiffFindOptionsMethod t DiffFindOptions, O.OverloadedMethod info DiffFindOptions p, R.HasField t DiffFindOptions p) => R.HasField t DiffFindOptions p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDiffFindOptionsMethod t DiffFindOptions, O.OverloadedMethodInfo info DiffFindOptions) => OL.IsLabel t (O.MethodProxy info DiffFindOptions) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsCopyThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m Word32
getDiffFindOptionsCopyThreshold o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"copy-threshold"
setDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsCopyThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> Word32 -> m ()
setDiffFindOptionsCopyThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"copy-threshold" Word32
val
constructDiffFindOptionsCopyThreshold :: (IsDiffFindOptions o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructDiffFindOptionsCopyThreshold :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructDiffFindOptionsCopyThreshold Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"copy-threshold" Word32
val
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsCopyThresholdPropertyInfo
instance AttrInfo DiffFindOptionsCopyThresholdPropertyInfo where
type AttrAllowedOps DiffFindOptionsCopyThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32
type AttrTransferTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32
type AttrTransferType DiffFindOptionsCopyThresholdPropertyInfo = Word32
type AttrGetType DiffFindOptionsCopyThresholdPropertyInfo = Word32
type AttrLabel DiffFindOptionsCopyThresholdPropertyInfo = "copy-threshold"
type AttrOrigin DiffFindOptionsCopyThresholdPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsCopyThreshold
attrSet = setDiffFindOptionsCopyThreshold
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsCopyThreshold
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.copyThreshold"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:copyThreshold"
})
#endif
getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [Ggit.Flags.DiffFindFlags]
getDiffFindOptionsFlags :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m [DiffFindFlags]
getDiffFindOptionsFlags o
obj = IO [DiffFindFlags] -> m [DiffFindFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [DiffFindFlags] -> m [DiffFindFlags])
-> IO [DiffFindFlags] -> m [DiffFindFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [DiffFindFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"flags"
setDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> [Ggit.Flags.DiffFindFlags] -> m ()
setDiffFindOptionsFlags :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> [DiffFindFlags] -> m ()
setDiffFindOptionsFlags o
obj [DiffFindFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> [DiffFindFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"flags" [DiffFindFlags]
val
constructDiffFindOptionsFlags :: (IsDiffFindOptions o, MIO.MonadIO m) => [Ggit.Flags.DiffFindFlags] -> m (GValueConstruct o)
constructDiffFindOptionsFlags :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
[DiffFindFlags] -> m (GValueConstruct o)
constructDiffFindOptionsFlags [DiffFindFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [DiffFindFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"flags" [DiffFindFlags]
val
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsFlagsPropertyInfo
instance AttrInfo DiffFindOptionsFlagsPropertyInfo where
type AttrAllowedOps DiffFindOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsFlagsPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags]
type AttrTransferTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags]
type AttrTransferType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags]
type AttrGetType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags]
type AttrLabel DiffFindOptionsFlagsPropertyInfo = "flags"
type AttrOrigin DiffFindOptionsFlagsPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsFlags
attrSet = setDiffFindOptionsFlags
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsFlags
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:flags"
})
#endif
getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
getDiffFindOptionsMetric :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m (Maybe DiffSimilarityMetric)
getDiffFindOptionsMetric o
obj = IO (Maybe DiffSimilarityMetric) -> m (Maybe DiffSimilarityMetric)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe DiffSimilarityMetric) -> m (Maybe DiffSimilarityMetric))
-> IO (Maybe DiffSimilarityMetric)
-> m (Maybe DiffSimilarityMetric)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr DiffSimilarityMetric -> DiffSimilarityMetric)
-> IO (Maybe DiffSimilarityMetric)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"metric" ManagedPtr DiffSimilarityMetric -> DiffSimilarityMetric
Ggit.DiffSimilarityMetric.DiffSimilarityMetric
setDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()
setDiffFindOptionsMetric :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> DiffSimilarityMetric -> m ()
setDiffFindOptionsMetric o
obj DiffSimilarityMetric
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe DiffSimilarityMetric -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"metric" (DiffSimilarityMetric -> Maybe DiffSimilarityMetric
forall a. a -> Maybe a
Just DiffSimilarityMetric
val)
constructDiffFindOptionsMetric :: (IsDiffFindOptions o, MIO.MonadIO m) => Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m (GValueConstruct o)
constructDiffFindOptionsMetric :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
DiffSimilarityMetric -> m (GValueConstruct o)
constructDiffFindOptionsMetric DiffSimilarityMetric
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe DiffSimilarityMetric -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"metric" (DiffSimilarityMetric -> Maybe DiffSimilarityMetric
forall a. a -> Maybe a
P.Just DiffSimilarityMetric
val)
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsMetricPropertyInfo
instance AttrInfo DiffFindOptionsMetricPropertyInfo where
type AttrAllowedOps DiffFindOptionsMetricPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsMetricPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric
type AttrTransferTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric
type AttrTransferType DiffFindOptionsMetricPropertyInfo = Ggit.DiffSimilarityMetric.DiffSimilarityMetric
type AttrGetType DiffFindOptionsMetricPropertyInfo = (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
type AttrLabel DiffFindOptionsMetricPropertyInfo = "metric"
type AttrOrigin DiffFindOptionsMetricPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsMetric
attrSet = setDiffFindOptionsMetric
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsMetric
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.metric"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:metric"
})
#endif
getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"rename-from-rewrite-threshold"
setDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameFromRewriteThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> Word32 -> m ()
setDiffFindOptionsRenameFromRewriteThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"rename-from-rewrite-threshold" Word32
val
constructDiffFindOptionsRenameFromRewriteThreshold :: (IsDiffFindOptions o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameFromRewriteThreshold :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameFromRewriteThreshold Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"rename-from-rewrite-threshold" Word32
val
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameFromRewriteThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameFromRewriteThresholdPropertyInfo where
type AttrAllowedOps DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32
type AttrTransferTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32
type AttrTransferType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32
type AttrGetType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32
type AttrLabel DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = "rename-from-rewrite-threshold"
type AttrOrigin DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsRenameFromRewriteThreshold
attrSet = setDiffFindOptionsRenameFromRewriteThreshold
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsRenameFromRewriteThreshold
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.renameFromRewriteThreshold"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:renameFromRewriteThreshold"
})
#endif
getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameLimit :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m Word32
getDiffFindOptionsRenameLimit o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"rename-limit"
setDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameLimit :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> Word32 -> m ()
setDiffFindOptionsRenameLimit o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"rename-limit" Word32
val
constructDiffFindOptionsRenameLimit :: (IsDiffFindOptions o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameLimit :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameLimit Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"rename-limit" Word32
val
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameLimitPropertyInfo
instance AttrInfo DiffFindOptionsRenameLimitPropertyInfo where
type AttrAllowedOps DiffFindOptionsRenameLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32
type AttrTransferTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32
type AttrTransferType DiffFindOptionsRenameLimitPropertyInfo = Word32
type AttrGetType DiffFindOptionsRenameLimitPropertyInfo = Word32
type AttrLabel DiffFindOptionsRenameLimitPropertyInfo = "rename-limit"
type AttrOrigin DiffFindOptionsRenameLimitPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsRenameLimit
attrSet = setDiffFindOptionsRenameLimit
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsRenameLimit
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.renameLimit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:renameLimit"
})
#endif
getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> m Word32
getDiffFindOptionsRenameThreshold o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"rename-threshold"
setDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
setDiffFindOptionsRenameThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsDiffFindOptions o) =>
o -> Word32 -> m ()
setDiffFindOptionsRenameThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"rename-threshold" Word32
val
constructDiffFindOptionsRenameThreshold :: (IsDiffFindOptions o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameThreshold :: forall o (m :: * -> *).
(IsDiffFindOptions o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructDiffFindOptionsRenameThreshold Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"rename-threshold" Word32
val
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsRenameThresholdPropertyInfo
instance AttrInfo DiffFindOptionsRenameThresholdPropertyInfo where
type AttrAllowedOps DiffFindOptionsRenameThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = IsDiffFindOptions
type AttrSetTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32
type AttrTransferTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32
type AttrTransferType DiffFindOptionsRenameThresholdPropertyInfo = Word32
type AttrGetType DiffFindOptionsRenameThresholdPropertyInfo = Word32
type AttrLabel DiffFindOptionsRenameThresholdPropertyInfo = "rename-threshold"
type AttrOrigin DiffFindOptionsRenameThresholdPropertyInfo = DiffFindOptions
attrGet = getDiffFindOptionsRenameThreshold
attrSet = setDiffFindOptionsRenameThreshold
attrTransfer _ v = do
return v
attrConstruct = constructDiffFindOptionsRenameThreshold
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.renameThreshold"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#g:attr:renameThreshold"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DiffFindOptions
type instance O.AttributeList DiffFindOptions = DiffFindOptionsAttributeList
type DiffFindOptionsAttributeList = ('[ '("copyThreshold", DiffFindOptionsCopyThresholdPropertyInfo), '("flags", DiffFindOptionsFlagsPropertyInfo), '("metric", DiffFindOptionsMetricPropertyInfo), '("renameFromRewriteThreshold", DiffFindOptionsRenameFromRewriteThresholdPropertyInfo), '("renameLimit", DiffFindOptionsRenameLimitPropertyInfo), '("renameThreshold", DiffFindOptionsRenameThresholdPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
diffFindOptionsCopyThreshold :: AttrLabelProxy "copyThreshold"
diffFindOptionsCopyThreshold = AttrLabelProxy
diffFindOptionsFlags :: AttrLabelProxy "flags"
diffFindOptionsFlags = AttrLabelProxy
diffFindOptionsMetric :: AttrLabelProxy "metric"
diffFindOptionsMetric = AttrLabelProxy
diffFindOptionsRenameFromRewriteThreshold :: AttrLabelProxy "renameFromRewriteThreshold"
diffFindOptionsRenameFromRewriteThreshold = AttrLabelProxy
diffFindOptionsRenameLimit :: AttrLabelProxy "renameLimit"
diffFindOptionsRenameLimit = AttrLabelProxy
diffFindOptionsRenameThreshold :: AttrLabelProxy "renameThreshold"
diffFindOptionsRenameThreshold = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DiffFindOptions = DiffFindOptionsSignalList
type DiffFindOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_diff_find_options_new" ggit_diff_find_options_new ::
IO (Ptr DiffFindOptions)
diffFindOptionsNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m (Maybe DiffFindOptions)
diffFindOptionsNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe DiffFindOptions)
diffFindOptionsNew = IO (Maybe DiffFindOptions) -> m (Maybe DiffFindOptions)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DiffFindOptions) -> m (Maybe DiffFindOptions))
-> IO (Maybe DiffFindOptions) -> m (Maybe DiffFindOptions)
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
result <- IO (Ptr DiffFindOptions)
ggit_diff_find_options_new
Maybe DiffFindOptions
maybeResult <- Ptr DiffFindOptions
-> (Ptr DiffFindOptions -> IO DiffFindOptions)
-> IO (Maybe DiffFindOptions)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DiffFindOptions
result ((Ptr DiffFindOptions -> IO DiffFindOptions)
-> IO (Maybe DiffFindOptions))
-> (Ptr DiffFindOptions -> IO DiffFindOptions)
-> IO (Maybe DiffFindOptions)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffFindOptions
result' -> do
DiffFindOptions
result'' <- ((ManagedPtr DiffFindOptions -> DiffFindOptions)
-> Ptr DiffFindOptions -> IO DiffFindOptions
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiffFindOptions -> DiffFindOptions
DiffFindOptions) Ptr DiffFindOptions
result'
DiffFindOptions -> IO DiffFindOptions
forall (m :: * -> *) a. Monad m => a -> m a
return DiffFindOptions
result''
Maybe DiffFindOptions -> IO (Maybe DiffFindOptions)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffFindOptions
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_diff_find_options_get_copy_threshold" ggit_diff_find_options_get_copy_threshold ::
Ptr DiffFindOptions ->
IO Word32
diffFindOptionsGetCopyThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m Word32
diffFindOptionsGetCopyThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m Word32
diffFindOptionsGetCopyThreshold a
options = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Word32
result <- Ptr DiffFindOptions -> IO Word32
ggit_diff_find_options_get_copy_threshold Ptr DiffFindOptions
options'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetCopyThresholdMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetCopyThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsGetCopyThreshold
instance O.OverloadedMethodInfo DiffFindOptionsGetCopyThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetCopyThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetCopyThreshold"
})
#endif
foreign import ccall "ggit_diff_find_options_get_flags" ggit_diff_find_options_get_flags ::
Ptr DiffFindOptions ->
IO CUInt
diffFindOptionsGetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m [Ggit.Flags.DiffFindFlags]
diffFindOptionsGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m [DiffFindFlags]
diffFindOptionsGetFlags a
options = IO [DiffFindFlags] -> m [DiffFindFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DiffFindFlags] -> m [DiffFindFlags])
-> IO [DiffFindFlags] -> m [DiffFindFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
CUInt
result <- Ptr DiffFindOptions -> IO CUInt
ggit_diff_find_options_get_flags Ptr DiffFindOptions
options'
let result' :: [DiffFindFlags]
result' = CUInt -> [DiffFindFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
[DiffFindFlags] -> IO [DiffFindFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [DiffFindFlags]
result'
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetFlagsMethodInfo
instance (signature ~ (m [Ggit.Flags.DiffFindFlags]), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetFlagsMethodInfo a signature where
overloadedMethod = diffFindOptionsGetFlags
instance O.OverloadedMethodInfo DiffFindOptionsGetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetFlags"
})
#endif
foreign import ccall "ggit_diff_find_options_get_metric" ggit_diff_find_options_get_metric ::
Ptr DiffFindOptions ->
IO (Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
diffFindOptionsGetMetric ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
diffFindOptionsGetMetric :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m (Maybe DiffSimilarityMetric)
diffFindOptionsGetMetric a
options = IO (Maybe DiffSimilarityMetric) -> m (Maybe DiffSimilarityMetric)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DiffSimilarityMetric) -> m (Maybe DiffSimilarityMetric))
-> IO (Maybe DiffSimilarityMetric)
-> m (Maybe DiffSimilarityMetric)
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffSimilarityMetric
result <- Ptr DiffFindOptions -> IO (Ptr DiffSimilarityMetric)
ggit_diff_find_options_get_metric Ptr DiffFindOptions
options'
Maybe DiffSimilarityMetric
maybeResult <- Ptr DiffSimilarityMetric
-> (Ptr DiffSimilarityMetric -> IO DiffSimilarityMetric)
-> IO (Maybe DiffSimilarityMetric)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DiffSimilarityMetric
result ((Ptr DiffSimilarityMetric -> IO DiffSimilarityMetric)
-> IO (Maybe DiffSimilarityMetric))
-> (Ptr DiffSimilarityMetric -> IO DiffSimilarityMetric)
-> IO (Maybe DiffSimilarityMetric)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffSimilarityMetric
result' -> do
DiffSimilarityMetric
result'' <- ((ManagedPtr DiffSimilarityMetric -> DiffSimilarityMetric)
-> Ptr DiffSimilarityMetric -> IO DiffSimilarityMetric
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DiffSimilarityMetric -> DiffSimilarityMetric
Ggit.DiffSimilarityMetric.DiffSimilarityMetric) Ptr DiffSimilarityMetric
result'
DiffSimilarityMetric -> IO DiffSimilarityMetric
forall (m :: * -> *) a. Monad m => a -> m a
return DiffSimilarityMetric
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Maybe DiffSimilarityMetric -> IO (Maybe DiffSimilarityMetric)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffSimilarityMetric
maybeResult
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetMetricMethodInfo
instance (signature ~ (m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetMetricMethodInfo a signature where
overloadedMethod = diffFindOptionsGetMetric
instance O.OverloadedMethodInfo DiffFindOptionsGetMetricMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetMetric",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetMetric"
})
#endif
foreign import ccall "ggit_diff_find_options_get_rename_from_rewrite_threshold" ggit_diff_find_options_get_rename_from_rewrite_threshold ::
Ptr DiffFindOptions ->
IO Word32
diffFindOptionsGetRenameFromRewriteThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m Word32
diffFindOptionsGetRenameFromRewriteThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m Word32
diffFindOptionsGetRenameFromRewriteThreshold a
options = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Word32
result <- Ptr DiffFindOptions -> IO Word32
ggit_diff_find_options_get_rename_from_rewrite_threshold Ptr DiffFindOptions
options'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsGetRenameFromRewriteThreshold
instance O.OverloadedMethodInfo DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetRenameFromRewriteThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetRenameFromRewriteThreshold"
})
#endif
foreign import ccall "ggit_diff_find_options_get_rename_limit" ggit_diff_find_options_get_rename_limit ::
Ptr DiffFindOptions ->
IO Word64
diffFindOptionsGetRenameLimit ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m Word64
diffFindOptionsGetRenameLimit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m Word64
diffFindOptionsGetRenameLimit a
options = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Word64
result <- Ptr DiffFindOptions -> IO Word64
ggit_diff_find_options_get_rename_limit Ptr DiffFindOptions
options'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetRenameLimitMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetRenameLimitMethodInfo a signature where
overloadedMethod = diffFindOptionsGetRenameLimit
instance O.OverloadedMethodInfo DiffFindOptionsGetRenameLimitMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetRenameLimit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetRenameLimit"
})
#endif
foreign import ccall "ggit_diff_find_options_get_rename_threshold" ggit_diff_find_options_get_rename_threshold ::
Ptr DiffFindOptions ->
IO Word32
diffFindOptionsGetRenameThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> m Word32
diffFindOptionsGetRenameThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> m Word32
diffFindOptionsGetRenameThreshold a
options = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Word32
result <- Ptr DiffFindOptions -> IO Word32
ggit_diff_find_options_get_rename_threshold Ptr DiffFindOptions
options'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsGetRenameThresholdMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsGetRenameThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsGetRenameThreshold
instance O.OverloadedMethodInfo DiffFindOptionsGetRenameThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsGetRenameThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsGetRenameThreshold"
})
#endif
foreign import ccall "ggit_diff_find_options_set_copy_threshold" ggit_diff_find_options_set_copy_threshold ::
Ptr DiffFindOptions ->
Word32 ->
IO ()
diffFindOptionsSetCopyThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> Word32
-> m ()
diffFindOptionsSetCopyThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> Word32 -> m ()
diffFindOptionsSetCopyThreshold a
options Word32
threshold = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffFindOptions -> Word32 -> IO ()
ggit_diff_find_options_set_copy_threshold Ptr DiffFindOptions
options' Word32
threshold
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetCopyThresholdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetCopyThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsSetCopyThreshold
instance O.OverloadedMethodInfo DiffFindOptionsSetCopyThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetCopyThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetCopyThreshold"
})
#endif
foreign import ccall "ggit_diff_find_options_set_flags" ggit_diff_find_options_set_flags ::
Ptr DiffFindOptions ->
CUInt ->
IO ()
diffFindOptionsSetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> [Ggit.Flags.DiffFindFlags]
-> m ()
diffFindOptionsSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> [DiffFindFlags] -> m ()
diffFindOptionsSetFlags a
options [DiffFindFlags]
flags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
let flags' :: CUInt
flags' = [DiffFindFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DiffFindFlags]
flags
Ptr DiffFindOptions -> CUInt -> IO ()
ggit_diff_find_options_set_flags Ptr DiffFindOptions
options' CUInt
flags'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetFlagsMethodInfo
instance (signature ~ ([Ggit.Flags.DiffFindFlags] -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetFlagsMethodInfo a signature where
overloadedMethod = diffFindOptionsSetFlags
instance O.OverloadedMethodInfo DiffFindOptionsSetFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetFlags"
})
#endif
foreign import ccall "ggit_diff_find_options_set_metric" ggit_diff_find_options_set_metric ::
Ptr DiffFindOptions ->
Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric ->
IO ()
diffFindOptionsSetMetric ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> Ggit.DiffSimilarityMetric.DiffSimilarityMetric
-> m ()
diffFindOptionsSetMetric :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> DiffSimilarityMetric -> m ()
diffFindOptionsSetMetric a
options DiffSimilarityMetric
metric = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffSimilarityMetric
metric' <- DiffSimilarityMetric -> IO (Ptr DiffSimilarityMetric)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffSimilarityMetric
metric
Ptr DiffFindOptions -> Ptr DiffSimilarityMetric -> IO ()
ggit_diff_find_options_set_metric Ptr DiffFindOptions
options' Ptr DiffSimilarityMetric
metric'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
DiffSimilarityMetric -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffSimilarityMetric
metric
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetMetricMethodInfo
instance (signature ~ (Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetMetricMethodInfo a signature where
overloadedMethod = diffFindOptionsSetMetric
instance O.OverloadedMethodInfo DiffFindOptionsSetMetricMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetMetric",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetMetric"
})
#endif
foreign import ccall "ggit_diff_find_options_set_rename_from_rewrite_threshold" ggit_diff_find_options_set_rename_from_rewrite_threshold ::
Ptr DiffFindOptions ->
Word32 ->
IO ()
diffFindOptionsSetRenameFromRewriteThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> Word32
-> m ()
diffFindOptionsSetRenameFromRewriteThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> Word32 -> m ()
diffFindOptionsSetRenameFromRewriteThreshold a
options Word32
threshold = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffFindOptions -> Word32 -> IO ()
ggit_diff_find_options_set_rename_from_rewrite_threshold Ptr DiffFindOptions
options' Word32
threshold
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsSetRenameFromRewriteThreshold
instance O.OverloadedMethodInfo DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetRenameFromRewriteThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetRenameFromRewriteThreshold"
})
#endif
foreign import ccall "ggit_diff_find_options_set_rename_limit" ggit_diff_find_options_set_rename_limit ::
Ptr DiffFindOptions ->
Word64 ->
IO ()
diffFindOptionsSetRenameLimit ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> Word64
-> m ()
diffFindOptionsSetRenameLimit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> Word64 -> m ()
diffFindOptionsSetRenameLimit a
options Word64
limit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffFindOptions -> Word64 -> IO ()
ggit_diff_find_options_set_rename_limit Ptr DiffFindOptions
options' Word64
limit
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetRenameLimitMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetRenameLimitMethodInfo a signature where
overloadedMethod = diffFindOptionsSetRenameLimit
instance O.OverloadedMethodInfo DiffFindOptionsSetRenameLimitMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetRenameLimit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetRenameLimit"
})
#endif
foreign import ccall "ggit_diff_find_options_set_rename_threshold" ggit_diff_find_options_set_rename_threshold ::
Ptr DiffFindOptions ->
Word32 ->
IO ()
diffFindOptionsSetRenameThreshold ::
(B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a
-> Word32
-> m ()
diffFindOptionsSetRenameThreshold :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiffFindOptions a) =>
a -> Word32 -> m ()
diffFindOptionsSetRenameThreshold a
options Word32
threshold = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffFindOptions
options' <- a -> IO (Ptr DiffFindOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr DiffFindOptions -> Word32 -> IO ()
ggit_diff_find_options_set_rename_threshold Ptr DiffFindOptions
options' Word32
threshold
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffFindOptionsSetRenameThresholdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.OverloadedMethod DiffFindOptionsSetRenameThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsSetRenameThreshold
instance O.OverloadedMethodInfo DiffFindOptionsSetRenameThresholdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.DiffFindOptions.diffFindOptionsSetRenameThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-DiffFindOptions.html#v:diffFindOptionsSetRenameThreshold"
})
#endif