{-# 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.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
instance B.GValue.IsGValue DiffFindOptions where
toGValue :: DiffFindOptions -> IO GValue
toGValue DiffFindOptions
o = do
GType
gtype <- IO GType
c_ggit_diff_find_options_get_type
DiffFindOptions -> (Ptr DiffFindOptions -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiffFindOptions
o (GType
-> (GValue -> Ptr DiffFindOptions -> IO ())
-> Ptr DiffFindOptions
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr DiffFindOptions -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO DiffFindOptions
fromGValue GValue
gv = do
Ptr DiffFindOptions
ptr <- GValue -> IO (Ptr DiffFindOptions)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr DiffFindOptions)
(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
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 :: (MonadIO m, IsDiffFindOptions o) => o -> m DiffFindOptions
toDiffFindOptions :: o -> m DiffFindOptions
toDiffFindOptions = IO DiffFindOptions -> m DiffFindOptions
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr DiffFindOptions -> DiffFindOptions
DiffFindOptions
#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.MethodInfo 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
#endif
getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsCopyThreshold :: o -> m Word32
getDiffFindOptionsCopyThreshold o
obj = 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
$ 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 :: o -> Word32 -> m ()
setDiffFindOptionsCopyThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: 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
$ 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
#endif
getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [Ggit.Flags.DiffFindFlags]
getDiffFindOptionsFlags :: o -> m [DiffFindFlags]
getDiffFindOptionsFlags o
obj = 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
$ 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 :: o -> [DiffFindFlags] -> m ()
setDiffFindOptionsFlags o
obj [DiffFindFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: [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
$ 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
#endif
getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)
getDiffFindOptionsMetric :: o -> m (Maybe DiffSimilarityMetric)
getDiffFindOptionsMetric o
obj = 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
$ 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 :: o -> DiffSimilarityMetric -> m ()
setDiffFindOptionsMetric o
obj DiffSimilarityMetric
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: 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
$ 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
#endif
getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold :: o -> m Word32
getDiffFindOptionsRenameFromRewriteThreshold o
obj = 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
$ 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 :: o -> Word32 -> m ()
setDiffFindOptionsRenameFromRewriteThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: 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
$ 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
#endif
getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameLimit :: o -> m Word32
getDiffFindOptionsRenameLimit o
obj = 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
$ 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 :: o -> Word32 -> m ()
setDiffFindOptionsRenameLimit o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: 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
$ 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
#endif
getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32
getDiffFindOptionsRenameThreshold :: o -> m Word32
getDiffFindOptionsRenameThreshold o
obj = 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
$ 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 :: o -> Word32 -> m ()
setDiffFindOptionsRenameThreshold o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 :: 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
$ 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
#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 :: 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 :: 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.MethodInfo DiffFindOptionsGetCopyThresholdMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsGetFlagsMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsGetMetricMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsGetRenameLimitMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsGetRenameThresholdMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetCopyThresholdMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetFlagsMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetMetricMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetRenameLimitMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo DiffFindOptionsSetRenameThresholdMethodInfo a signature where
overloadedMethod = diffFindOptionsSetRenameThreshold
#endif