#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Flags
(
AttributeCheckFlags(..) ,
BlameFlags(..) ,
CheckoutNotifyFlags(..) ,
CheckoutStrategy(..) ,
CreateFlags(..) ,
Credtype(..) ,
DiffFindFlags(..) ,
DiffFlag(..) ,
DiffFormatEmailFlags(..) ,
DiffOption(..) ,
FeatureFlags(..) ,
MergeFileFlags(..) ,
MergeFlags(..) ,
SortMode(..) ,
StashFlags(..) ,
StatusFlags(..) ,
StatusOption(..) ,
SubmoduleStatus(..) ,
) 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.GHashTable as B.GHT
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.Kind as DK
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
data SubmoduleStatus =
SubmoduleStatusInHead
| SubmoduleStatusInIndex
| SubmoduleStatusInConfig
| SubmoduleStatusInWd
| SubmoduleStatusIndexAdded
| SubmoduleStatusIndexDeleted
| SubmoduleStatusIndexModified
| SubmoduleStatusWdUninitialized
| SubmoduleStatusWdAdded
| SubmoduleStatusWdDeleted
| SubmoduleStatusWdModified
| SubmoduleStatusWdIndexModified
| SubmoduleStatusWdWdModified
| SubmoduleStatusWdUntracked
| AnotherSubmoduleStatus Int
deriving (Int -> SubmoduleStatus -> ShowS
[SubmoduleStatus] -> ShowS
SubmoduleStatus -> String
(Int -> SubmoduleStatus -> ShowS)
-> (SubmoduleStatus -> String)
-> ([SubmoduleStatus] -> ShowS)
-> Show SubmoduleStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmoduleStatus -> ShowS
showsPrec :: Int -> SubmoduleStatus -> ShowS
$cshow :: SubmoduleStatus -> String
show :: SubmoduleStatus -> String
$cshowList :: [SubmoduleStatus] -> ShowS
showList :: [SubmoduleStatus] -> ShowS
Show, SubmoduleStatus -> SubmoduleStatus -> Bool
(SubmoduleStatus -> SubmoduleStatus -> Bool)
-> (SubmoduleStatus -> SubmoduleStatus -> Bool)
-> Eq SubmoduleStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmoduleStatus -> SubmoduleStatus -> Bool
== :: SubmoduleStatus -> SubmoduleStatus -> Bool
$c/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
Eq)
instance P.Enum SubmoduleStatus where
fromEnum :: SubmoduleStatus -> Int
fromEnum SubmoduleStatus
SubmoduleStatusInHead = Int
1
fromEnum SubmoduleStatus
SubmoduleStatusInIndex = Int
2
fromEnum SubmoduleStatus
SubmoduleStatusInConfig = Int
4
fromEnum SubmoduleStatus
SubmoduleStatusInWd = Int
8
fromEnum SubmoduleStatus
SubmoduleStatusIndexAdded = Int
16
fromEnum SubmoduleStatus
SubmoduleStatusIndexDeleted = Int
32
fromEnum SubmoduleStatus
SubmoduleStatusIndexModified = Int
64
fromEnum SubmoduleStatus
SubmoduleStatusWdUninitialized = Int
128
fromEnum SubmoduleStatus
SubmoduleStatusWdAdded = Int
256
fromEnum SubmoduleStatus
SubmoduleStatusWdDeleted = Int
512
fromEnum SubmoduleStatus
SubmoduleStatusWdModified = Int
1024
fromEnum SubmoduleStatus
SubmoduleStatusWdIndexModified = Int
2048
fromEnum SubmoduleStatus
SubmoduleStatusWdWdModified = Int
4096
fromEnum SubmoduleStatus
SubmoduleStatusWdUntracked = Int
8192
fromEnum (AnotherSubmoduleStatus Int
k) = Int
k
toEnum :: Int -> SubmoduleStatus
toEnum Int
1 = SubmoduleStatus
SubmoduleStatusInHead
toEnum Int
2 = SubmoduleStatus
SubmoduleStatusInIndex
toEnum Int
4 = SubmoduleStatus
SubmoduleStatusInConfig
toEnum Int
8 = SubmoduleStatus
SubmoduleStatusInWd
toEnum Int
16 = SubmoduleStatus
SubmoduleStatusIndexAdded
toEnum Int
32 = SubmoduleStatus
SubmoduleStatusIndexDeleted
toEnum Int
64 = SubmoduleStatus
SubmoduleStatusIndexModified
toEnum Int
128 = SubmoduleStatus
SubmoduleStatusWdUninitialized
toEnum Int
256 = SubmoduleStatus
SubmoduleStatusWdAdded
toEnum Int
512 = SubmoduleStatus
SubmoduleStatusWdDeleted
toEnum Int
1024 = SubmoduleStatus
SubmoduleStatusWdModified
toEnum Int
2048 = SubmoduleStatus
SubmoduleStatusWdIndexModified
toEnum Int
4096 = SubmoduleStatus
SubmoduleStatusWdWdModified
toEnum Int
8192 = SubmoduleStatus
SubmoduleStatusWdUntracked
toEnum Int
k = Int -> SubmoduleStatus
AnotherSubmoduleStatus Int
k
instance P.Ord SubmoduleStatus where
compare :: SubmoduleStatus -> SubmoduleStatus -> Ordering
compare SubmoduleStatus
a SubmoduleStatus
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleStatus
a) (SubmoduleStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleStatus
b)
type instance O.ParentTypes SubmoduleStatus = '[]
instance O.HasParentTypes SubmoduleStatus
foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type ::
IO GType
instance B.Types.TypedObject SubmoduleStatus where
glibType :: IO GType
glibType = IO GType
c_ggit_submodule_status_get_type
instance B.Types.BoxedFlags SubmoduleStatus
instance IsGFlag SubmoduleStatus
data StatusOption =
StatusOptionIncludeUntracked
| StatusOptionIncludeIgnored
| StatusOptionIncludeUnmodified
| StatusOptionExcludeSubmodules
| StatusOptionRecurseUntrackedDirs
| StatusOptionDisablePathspecMatch
| StatusOptionRecurseIgnoredDirs
| StatusOptionRenamesHeadToIndex
| StatusOptionRenamesIndexToWorkdir
| StatusOptionSortCaseSensitively
| StatusOptionSortCaseInsensitively
| StatusOptionDefault
| AnotherStatusOption Int
deriving (Int -> StatusOption -> ShowS
[StatusOption] -> ShowS
StatusOption -> String
(Int -> StatusOption -> ShowS)
-> (StatusOption -> String)
-> ([StatusOption] -> ShowS)
-> Show StatusOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusOption -> ShowS
showsPrec :: Int -> StatusOption -> ShowS
$cshow :: StatusOption -> String
show :: StatusOption -> String
$cshowList :: [StatusOption] -> ShowS
showList :: [StatusOption] -> ShowS
Show, StatusOption -> StatusOption -> Bool
(StatusOption -> StatusOption -> Bool)
-> (StatusOption -> StatusOption -> Bool) -> Eq StatusOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusOption -> StatusOption -> Bool
== :: StatusOption -> StatusOption -> Bool
$c/= :: StatusOption -> StatusOption -> Bool
/= :: StatusOption -> StatusOption -> Bool
Eq)
instance P.Enum StatusOption where
fromEnum :: StatusOption -> Int
fromEnum StatusOption
StatusOptionIncludeUntracked = Int
1
fromEnum StatusOption
StatusOptionIncludeIgnored = Int
2
fromEnum StatusOption
StatusOptionIncludeUnmodified = Int
4
fromEnum StatusOption
StatusOptionExcludeSubmodules = Int
8
fromEnum StatusOption
StatusOptionRecurseUntrackedDirs = Int
16
fromEnum StatusOption
StatusOptionDisablePathspecMatch = Int
32
fromEnum StatusOption
StatusOptionRecurseIgnoredDirs = Int
64
fromEnum StatusOption
StatusOptionRenamesHeadToIndex = Int
128
fromEnum StatusOption
StatusOptionRenamesIndexToWorkdir = Int
256
fromEnum StatusOption
StatusOptionSortCaseSensitively = Int
512
fromEnum StatusOption
StatusOptionSortCaseInsensitively = Int
1024
fromEnum StatusOption
StatusOptionDefault = Int
19
fromEnum (AnotherStatusOption Int
k) = Int
k
toEnum :: Int -> StatusOption
toEnum Int
1 = StatusOption
StatusOptionIncludeUntracked
toEnum Int
2 = StatusOption
StatusOptionIncludeIgnored
toEnum Int
4 = StatusOption
StatusOptionIncludeUnmodified
toEnum Int
8 = StatusOption
StatusOptionExcludeSubmodules
toEnum Int
16 = StatusOption
StatusOptionRecurseUntrackedDirs
toEnum Int
32 = StatusOption
StatusOptionDisablePathspecMatch
toEnum Int
64 = StatusOption
StatusOptionRecurseIgnoredDirs
toEnum Int
128 = StatusOption
StatusOptionRenamesHeadToIndex
toEnum Int
256 = StatusOption
StatusOptionRenamesIndexToWorkdir
toEnum Int
512 = StatusOption
StatusOptionSortCaseSensitively
toEnum Int
1024 = StatusOption
StatusOptionSortCaseInsensitively
toEnum Int
19 = StatusOption
StatusOptionDefault
toEnum Int
k = Int -> StatusOption
AnotherStatusOption Int
k
instance P.Ord StatusOption where
compare :: StatusOption -> StatusOption -> Ordering
compare StatusOption
a StatusOption
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StatusOption -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusOption
a) (StatusOption -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusOption
b)
type instance O.ParentTypes StatusOption = '[]
instance O.HasParentTypes StatusOption
foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type ::
IO GType
instance B.Types.TypedObject StatusOption where
glibType :: IO GType
glibType = IO GType
c_ggit_status_option_get_type
instance B.Types.BoxedFlags StatusOption
instance IsGFlag StatusOption
data StatusFlags =
StatusFlagsCurrent
| StatusFlagsIndexNew
| StatusFlagsIndexModified
| StatusFlagsIndexDeleted
| StatusFlagsIndexRenamed
| StatusFlagsIndexTypechange
| StatusFlagsWorkingTreeNew
| StatusFlagsWorkingTreeModified
| StatusFlagsWorkingTreeDeleted
| StatusFlagsWorkingTreeTypechange
| StatusFlagsWorkingTreeRenamed
| StatusFlagsWorkingTreeUnreadable
| StatusFlagsIgnored
| StatusFlagsConflicted
| AnotherStatusFlags Int
deriving (Int -> StatusFlags -> ShowS
[StatusFlags] -> ShowS
StatusFlags -> String
(Int -> StatusFlags -> ShowS)
-> (StatusFlags -> String)
-> ([StatusFlags] -> ShowS)
-> Show StatusFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusFlags -> ShowS
showsPrec :: Int -> StatusFlags -> ShowS
$cshow :: StatusFlags -> String
show :: StatusFlags -> String
$cshowList :: [StatusFlags] -> ShowS
showList :: [StatusFlags] -> ShowS
Show, StatusFlags -> StatusFlags -> Bool
(StatusFlags -> StatusFlags -> Bool)
-> (StatusFlags -> StatusFlags -> Bool) -> Eq StatusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusFlags -> StatusFlags -> Bool
== :: StatusFlags -> StatusFlags -> Bool
$c/= :: StatusFlags -> StatusFlags -> Bool
/= :: StatusFlags -> StatusFlags -> Bool
Eq)
instance P.Enum StatusFlags where
fromEnum :: StatusFlags -> Int
fromEnum StatusFlags
StatusFlagsCurrent = Int
0
fromEnum StatusFlags
StatusFlagsIndexNew = Int
1
fromEnum StatusFlags
StatusFlagsIndexModified = Int
2
fromEnum StatusFlags
StatusFlagsIndexDeleted = Int
4
fromEnum StatusFlags
StatusFlagsIndexRenamed = Int
8
fromEnum StatusFlags
StatusFlagsIndexTypechange = Int
16
fromEnum StatusFlags
StatusFlagsWorkingTreeNew = Int
128
fromEnum StatusFlags
StatusFlagsWorkingTreeModified = Int
256
fromEnum StatusFlags
StatusFlagsWorkingTreeDeleted = Int
512
fromEnum StatusFlags
StatusFlagsWorkingTreeTypechange = Int
1024
fromEnum StatusFlags
StatusFlagsWorkingTreeRenamed = Int
2048
fromEnum StatusFlags
StatusFlagsWorkingTreeUnreadable = Int
4096
fromEnum StatusFlags
StatusFlagsIgnored = Int
16384
fromEnum StatusFlags
StatusFlagsConflicted = Int
32768
fromEnum (AnotherStatusFlags Int
k) = Int
k
toEnum :: Int -> StatusFlags
toEnum Int
0 = StatusFlags
StatusFlagsCurrent
toEnum Int
1 = StatusFlags
StatusFlagsIndexNew
toEnum Int
2 = StatusFlags
StatusFlagsIndexModified
toEnum Int
4 = StatusFlags
StatusFlagsIndexDeleted
toEnum Int
8 = StatusFlags
StatusFlagsIndexRenamed
toEnum Int
16 = StatusFlags
StatusFlagsIndexTypechange
toEnum Int
128 = StatusFlags
StatusFlagsWorkingTreeNew
toEnum Int
256 = StatusFlags
StatusFlagsWorkingTreeModified
toEnum Int
512 = StatusFlags
StatusFlagsWorkingTreeDeleted
toEnum Int
1024 = StatusFlags
StatusFlagsWorkingTreeTypechange
toEnum Int
2048 = StatusFlags
StatusFlagsWorkingTreeRenamed
toEnum Int
4096 = StatusFlags
StatusFlagsWorkingTreeUnreadable
toEnum Int
16384 = StatusFlags
StatusFlagsIgnored
toEnum Int
32768 = StatusFlags
StatusFlagsConflicted
toEnum Int
k = Int -> StatusFlags
AnotherStatusFlags Int
k
instance P.Ord StatusFlags where
compare :: StatusFlags -> StatusFlags -> Ordering
compare StatusFlags
a StatusFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StatusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusFlags
a) (StatusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusFlags
b)
type instance O.ParentTypes StatusFlags = '[]
instance O.HasParentTypes StatusFlags
foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type ::
IO GType
instance B.Types.TypedObject StatusFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_status_flags_get_type
instance B.Types.BoxedFlags StatusFlags
instance IsGFlag StatusFlags
data StashFlags =
StashFlagsDefault
| StashFlagsKeepIndex
| StashFlagsIncludeUntracked
| StashFlagsIncludeIgnored
| AnotherStashFlags Int
deriving (Int -> StashFlags -> ShowS
[StashFlags] -> ShowS
StashFlags -> String
(Int -> StashFlags -> ShowS)
-> (StashFlags -> String)
-> ([StashFlags] -> ShowS)
-> Show StashFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StashFlags -> ShowS
showsPrec :: Int -> StashFlags -> ShowS
$cshow :: StashFlags -> String
show :: StashFlags -> String
$cshowList :: [StashFlags] -> ShowS
showList :: [StashFlags] -> ShowS
Show, StashFlags -> StashFlags -> Bool
(StashFlags -> StashFlags -> Bool)
-> (StashFlags -> StashFlags -> Bool) -> Eq StashFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StashFlags -> StashFlags -> Bool
== :: StashFlags -> StashFlags -> Bool
$c/= :: StashFlags -> StashFlags -> Bool
/= :: StashFlags -> StashFlags -> Bool
Eq)
instance P.Enum StashFlags where
fromEnum :: StashFlags -> Int
fromEnum StashFlags
StashFlagsDefault = Int
0
fromEnum StashFlags
StashFlagsKeepIndex = Int
1
fromEnum StashFlags
StashFlagsIncludeUntracked = Int
2
fromEnum StashFlags
StashFlagsIncludeIgnored = Int
4
fromEnum (AnotherStashFlags Int
k) = Int
k
toEnum :: Int -> StashFlags
toEnum Int
0 = StashFlags
StashFlagsDefault
toEnum Int
1 = StashFlags
StashFlagsKeepIndex
toEnum Int
2 = StashFlags
StashFlagsIncludeUntracked
toEnum Int
4 = StashFlags
StashFlagsIncludeIgnored
toEnum Int
k = Int -> StashFlags
AnotherStashFlags Int
k
instance P.Ord StashFlags where
compare :: StashFlags -> StashFlags -> Ordering
compare StashFlags
a StashFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StashFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StashFlags
a) (StashFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StashFlags
b)
type instance O.ParentTypes StashFlags = '[]
instance O.HasParentTypes StashFlags
foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type ::
IO GType
instance B.Types.TypedObject StashFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_stash_flags_get_type
instance B.Types.BoxedFlags StashFlags
instance IsGFlag StashFlags
data SortMode =
SortModeNone
| SortModeTopological
| SortModeTime
| SortModeReverse
| AnotherSortMode Int
deriving (Int -> SortMode -> ShowS
[SortMode] -> ShowS
SortMode -> String
(Int -> SortMode -> ShowS)
-> (SortMode -> String) -> ([SortMode] -> ShowS) -> Show SortMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortMode -> ShowS
showsPrec :: Int -> SortMode -> ShowS
$cshow :: SortMode -> String
show :: SortMode -> String
$cshowList :: [SortMode] -> ShowS
showList :: [SortMode] -> ShowS
Show, SortMode -> SortMode -> Bool
(SortMode -> SortMode -> Bool)
-> (SortMode -> SortMode -> Bool) -> Eq SortMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortMode -> SortMode -> Bool
== :: SortMode -> SortMode -> Bool
$c/= :: SortMode -> SortMode -> Bool
/= :: SortMode -> SortMode -> Bool
Eq)
instance P.Enum SortMode where
fromEnum :: SortMode -> Int
fromEnum SortMode
SortModeNone = Int
0
fromEnum SortMode
SortModeTopological = Int
1
fromEnum SortMode
SortModeTime = Int
2
fromEnum SortMode
SortModeReverse = Int
4
fromEnum (AnotherSortMode Int
k) = Int
k
toEnum :: Int -> SortMode
toEnum Int
0 = SortMode
SortModeNone
toEnum Int
1 = SortMode
SortModeTopological
toEnum Int
2 = SortMode
SortModeTime
toEnum Int
4 = SortMode
SortModeReverse
toEnum Int
k = Int -> SortMode
AnotherSortMode Int
k
instance P.Ord SortMode where
compare :: SortMode -> SortMode -> Ordering
compare SortMode
a SortMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SortMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SortMode
a) (SortMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SortMode
b)
type instance O.ParentTypes SortMode = '[]
instance O.HasParentTypes SortMode
foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type ::
IO GType
instance B.Types.TypedObject SortMode where
glibType :: IO GType
glibType = IO GType
c_ggit_sort_mode_get_type
instance B.Types.BoxedFlags SortMode
instance IsGFlag SortMode
data MergeFlags =
MergeFlagsFindRenames
| MergeFlagsFailOnConflict
| MergeFlagsSkipReuc
| MergeFlagsNoRecursive
| AnotherMergeFlags Int
deriving (Int -> MergeFlags -> ShowS
[MergeFlags] -> ShowS
MergeFlags -> String
(Int -> MergeFlags -> ShowS)
-> (MergeFlags -> String)
-> ([MergeFlags] -> ShowS)
-> Show MergeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeFlags -> ShowS
showsPrec :: Int -> MergeFlags -> ShowS
$cshow :: MergeFlags -> String
show :: MergeFlags -> String
$cshowList :: [MergeFlags] -> ShowS
showList :: [MergeFlags] -> ShowS
Show, MergeFlags -> MergeFlags -> Bool
(MergeFlags -> MergeFlags -> Bool)
-> (MergeFlags -> MergeFlags -> Bool) -> Eq MergeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeFlags -> MergeFlags -> Bool
== :: MergeFlags -> MergeFlags -> Bool
$c/= :: MergeFlags -> MergeFlags -> Bool
/= :: MergeFlags -> MergeFlags -> Bool
Eq)
instance P.Enum MergeFlags where
fromEnum :: MergeFlags -> Int
fromEnum MergeFlags
MergeFlagsFindRenames = Int
1
fromEnum MergeFlags
MergeFlagsFailOnConflict = Int
2
fromEnum MergeFlags
MergeFlagsSkipReuc = Int
4
fromEnum MergeFlags
MergeFlagsNoRecursive = Int
8
fromEnum (AnotherMergeFlags Int
k) = Int
k
toEnum :: Int -> MergeFlags
toEnum Int
1 = MergeFlags
MergeFlagsFindRenames
toEnum Int
2 = MergeFlags
MergeFlagsFailOnConflict
toEnum Int
4 = MergeFlags
MergeFlagsSkipReuc
toEnum Int
8 = MergeFlags
MergeFlagsNoRecursive
toEnum Int
k = Int -> MergeFlags
AnotherMergeFlags Int
k
instance P.Ord MergeFlags where
compare :: MergeFlags -> MergeFlags -> Ordering
compare MergeFlags
a MergeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MergeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFlags
a) (MergeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFlags
b)
type instance O.ParentTypes MergeFlags = '[]
instance O.HasParentTypes MergeFlags
foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type ::
IO GType
instance B.Types.TypedObject MergeFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_merge_flags_get_type
instance B.Types.BoxedFlags MergeFlags
instance IsGFlag MergeFlags
data MergeFileFlags =
MergeFileFlagsDefault
| MergeFileFlagsStyleMerge
| MergeFileFlagsStyleDiff3
| MergeFileFlagsSimplifyAlnum
| MergeFileFlagsIgnoreWhitespace
| MergeFileFlagsIgnoreWhitespaceChange
| MergeFileFlagsIgnoreWhitespaceEol
| MergeFileFlagsDiffPatience
| MergeFileFlagsDiffMinimal
| AnotherMergeFileFlags Int
deriving (Int -> MergeFileFlags -> ShowS
[MergeFileFlags] -> ShowS
MergeFileFlags -> String
(Int -> MergeFileFlags -> ShowS)
-> (MergeFileFlags -> String)
-> ([MergeFileFlags] -> ShowS)
-> Show MergeFileFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeFileFlags -> ShowS
showsPrec :: Int -> MergeFileFlags -> ShowS
$cshow :: MergeFileFlags -> String
show :: MergeFileFlags -> String
$cshowList :: [MergeFileFlags] -> ShowS
showList :: [MergeFileFlags] -> ShowS
Show, MergeFileFlags -> MergeFileFlags -> Bool
(MergeFileFlags -> MergeFileFlags -> Bool)
-> (MergeFileFlags -> MergeFileFlags -> Bool) -> Eq MergeFileFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeFileFlags -> MergeFileFlags -> Bool
== :: MergeFileFlags -> MergeFileFlags -> Bool
$c/= :: MergeFileFlags -> MergeFileFlags -> Bool
/= :: MergeFileFlags -> MergeFileFlags -> Bool
Eq)
instance P.Enum MergeFileFlags where
fromEnum :: MergeFileFlags -> Int
fromEnum MergeFileFlags
MergeFileFlagsDefault = Int
0
fromEnum MergeFileFlags
MergeFileFlagsStyleMerge = Int
1
fromEnum MergeFileFlags
MergeFileFlagsStyleDiff3 = Int
2
fromEnum MergeFileFlags
MergeFileFlagsSimplifyAlnum = Int
4
fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespace = Int
8
fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespaceChange = Int
16
fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespaceEol = Int
32
fromEnum MergeFileFlags
MergeFileFlagsDiffPatience = Int
64
fromEnum MergeFileFlags
MergeFileFlagsDiffMinimal = Int
128
fromEnum (AnotherMergeFileFlags Int
k) = Int
k
toEnum :: Int -> MergeFileFlags
toEnum Int
0 = MergeFileFlags
MergeFileFlagsDefault
toEnum Int
1 = MergeFileFlags
MergeFileFlagsStyleMerge
toEnum Int
2 = MergeFileFlags
MergeFileFlagsStyleDiff3
toEnum Int
4 = MergeFileFlags
MergeFileFlagsSimplifyAlnum
toEnum Int
8 = MergeFileFlags
MergeFileFlagsIgnoreWhitespace
toEnum Int
16 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceChange
toEnum Int
32 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceEol
toEnum Int
64 = MergeFileFlags
MergeFileFlagsDiffPatience
toEnum Int
128 = MergeFileFlags
MergeFileFlagsDiffMinimal
toEnum Int
k = Int -> MergeFileFlags
AnotherMergeFileFlags Int
k
instance P.Ord MergeFileFlags where
compare :: MergeFileFlags -> MergeFileFlags -> Ordering
compare MergeFileFlags
a MergeFileFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MergeFileFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFlags
a) (MergeFileFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFlags
b)
type instance O.ParentTypes MergeFileFlags = '[]
instance O.HasParentTypes MergeFileFlags
foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type ::
IO GType
instance B.Types.TypedObject MergeFileFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_merge_file_flags_get_type
instance B.Types.BoxedFlags MergeFileFlags
instance IsGFlag MergeFileFlags
data FeatureFlags =
FeatureFlagsThreads
| FeatureFlagsHttps
| FeatureFlagsSsh
| AnotherFeatureFlags Int
deriving (Int -> FeatureFlags -> ShowS
[FeatureFlags] -> ShowS
FeatureFlags -> String
(Int -> FeatureFlags -> ShowS)
-> (FeatureFlags -> String)
-> ([FeatureFlags] -> ShowS)
-> Show FeatureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FeatureFlags -> ShowS
showsPrec :: Int -> FeatureFlags -> ShowS
$cshow :: FeatureFlags -> String
show :: FeatureFlags -> String
$cshowList :: [FeatureFlags] -> ShowS
showList :: [FeatureFlags] -> ShowS
Show, FeatureFlags -> FeatureFlags -> Bool
(FeatureFlags -> FeatureFlags -> Bool)
-> (FeatureFlags -> FeatureFlags -> Bool) -> Eq FeatureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FeatureFlags -> FeatureFlags -> Bool
== :: FeatureFlags -> FeatureFlags -> Bool
$c/= :: FeatureFlags -> FeatureFlags -> Bool
/= :: FeatureFlags -> FeatureFlags -> Bool
Eq)
instance P.Enum FeatureFlags where
fromEnum :: FeatureFlags -> Int
fromEnum FeatureFlags
FeatureFlagsThreads = Int
1
fromEnum FeatureFlags
FeatureFlagsHttps = Int
2
fromEnum FeatureFlags
FeatureFlagsSsh = Int
4
fromEnum (AnotherFeatureFlags Int
k) = Int
k
toEnum :: Int -> FeatureFlags
toEnum Int
1 = FeatureFlags
FeatureFlagsThreads
toEnum Int
2 = FeatureFlags
FeatureFlagsHttps
toEnum Int
4 = FeatureFlags
FeatureFlagsSsh
toEnum Int
k = Int -> FeatureFlags
AnotherFeatureFlags Int
k
instance P.Ord FeatureFlags where
compare :: FeatureFlags -> FeatureFlags -> Ordering
compare FeatureFlags
a FeatureFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FeatureFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FeatureFlags
a) (FeatureFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum FeatureFlags
b)
type instance O.ParentTypes FeatureFlags = '[]
instance O.HasParentTypes FeatureFlags
foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type ::
IO GType
instance B.Types.TypedObject FeatureFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_feature_flags_get_type
instance B.Types.BoxedFlags FeatureFlags
instance IsGFlag FeatureFlags
data DiffOption =
DiffOptionNormal
| DiffOptionReverse
| DiffOptionIncludeIgnored
| DiffOptionRecurseIgnoredDirs
| DiffOptionIncludeUntracked
| DiffOptionRecurseUntrackedDirs
| DiffOptionIncludeUnmodified
| DiffOptionIncludeTypechange
| DiffOptionIncludeTypechangeTrees
| DiffOptionIgnoreFileMode
| DiffOptionIgnoreSubmodules
| DiffOptionIgnoreCase
| DiffOptionDisablePathspecMatch
| DiffOptionSkipBinaryCheck
| DiffOptionEnableFastUntrackedDirs
| DiffOptionForceText
| DiffOptionForceBinary
| DiffOptionIgnoreWhitespace
| DiffOptionIgnoreWhitespaceChange
| DiffOptionIgnoreWhitespaceEol
| DiffOptionShowUntrackedContent
| DiffOptionShowUnmodified
| DiffOptionPatience
| DiffOptionMinimal
| DiffOptionShowBinary
| AnotherDiffOption Int
deriving (Int -> DiffOption -> ShowS
[DiffOption] -> ShowS
DiffOption -> String
(Int -> DiffOption -> ShowS)
-> (DiffOption -> String)
-> ([DiffOption] -> ShowS)
-> Show DiffOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffOption -> ShowS
showsPrec :: Int -> DiffOption -> ShowS
$cshow :: DiffOption -> String
show :: DiffOption -> String
$cshowList :: [DiffOption] -> ShowS
showList :: [DiffOption] -> ShowS
Show, DiffOption -> DiffOption -> Bool
(DiffOption -> DiffOption -> Bool)
-> (DiffOption -> DiffOption -> Bool) -> Eq DiffOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffOption -> DiffOption -> Bool
== :: DiffOption -> DiffOption -> Bool
$c/= :: DiffOption -> DiffOption -> Bool
/= :: DiffOption -> DiffOption -> Bool
Eq)
instance P.Enum DiffOption where
fromEnum :: DiffOption -> Int
fromEnum DiffOption
DiffOptionNormal = Int
0
fromEnum DiffOption
DiffOptionReverse = Int
1
fromEnum DiffOption
DiffOptionIncludeIgnored = Int
2
fromEnum DiffOption
DiffOptionRecurseIgnoredDirs = Int
4
fromEnum DiffOption
DiffOptionIncludeUntracked = Int
8
fromEnum DiffOption
DiffOptionRecurseUntrackedDirs = Int
16
fromEnum DiffOption
DiffOptionIncludeUnmodified = Int
32
fromEnum DiffOption
DiffOptionIncludeTypechange = Int
64
fromEnum DiffOption
DiffOptionIncludeTypechangeTrees = Int
128
fromEnum DiffOption
DiffOptionIgnoreFileMode = Int
256
fromEnum DiffOption
DiffOptionIgnoreSubmodules = Int
512
fromEnum DiffOption
DiffOptionIgnoreCase = Int
1024
fromEnum DiffOption
DiffOptionDisablePathspecMatch = Int
4096
fromEnum DiffOption
DiffOptionSkipBinaryCheck = Int
8192
fromEnum DiffOption
DiffOptionEnableFastUntrackedDirs = Int
16384
fromEnum DiffOption
DiffOptionForceText = Int
1048576
fromEnum DiffOption
DiffOptionForceBinary = Int
2097152
fromEnum DiffOption
DiffOptionIgnoreWhitespace = Int
4194304
fromEnum DiffOption
DiffOptionIgnoreWhitespaceChange = Int
8388608
fromEnum DiffOption
DiffOptionIgnoreWhitespaceEol = Int
16777216
fromEnum DiffOption
DiffOptionShowUntrackedContent = Int
33554432
fromEnum DiffOption
DiffOptionShowUnmodified = Int
67108864
fromEnum DiffOption
DiffOptionPatience = Int
268435456
fromEnum DiffOption
DiffOptionMinimal = Int
536870912
fromEnum DiffOption
DiffOptionShowBinary = Int
1073741824
fromEnum (AnotherDiffOption Int
k) = Int
k
toEnum :: Int -> DiffOption
toEnum Int
0 = DiffOption
DiffOptionNormal
toEnum Int
1 = DiffOption
DiffOptionReverse
toEnum Int
2 = DiffOption
DiffOptionIncludeIgnored
toEnum Int
4 = DiffOption
DiffOptionRecurseIgnoredDirs
toEnum Int
8 = DiffOption
DiffOptionIncludeUntracked
toEnum Int
16 = DiffOption
DiffOptionRecurseUntrackedDirs
toEnum Int
32 = DiffOption
DiffOptionIncludeUnmodified
toEnum Int
64 = DiffOption
DiffOptionIncludeTypechange
toEnum Int
128 = DiffOption
DiffOptionIncludeTypechangeTrees
toEnum Int
256 = DiffOption
DiffOptionIgnoreFileMode
toEnum Int
512 = DiffOption
DiffOptionIgnoreSubmodules
toEnum Int
1024 = DiffOption
DiffOptionIgnoreCase
toEnum Int
4096 = DiffOption
DiffOptionDisablePathspecMatch
toEnum Int
8192 = DiffOption
DiffOptionSkipBinaryCheck
toEnum Int
16384 = DiffOption
DiffOptionEnableFastUntrackedDirs
toEnum Int
1048576 = DiffOption
DiffOptionForceText
toEnum Int
2097152 = DiffOption
DiffOptionForceBinary
toEnum Int
4194304 = DiffOption
DiffOptionIgnoreWhitespace
toEnum Int
8388608 = DiffOption
DiffOptionIgnoreWhitespaceChange
toEnum Int
16777216 = DiffOption
DiffOptionIgnoreWhitespaceEol
toEnum Int
33554432 = DiffOption
DiffOptionShowUntrackedContent
toEnum Int
67108864 = DiffOption
DiffOptionShowUnmodified
toEnum Int
268435456 = DiffOption
DiffOptionPatience
toEnum Int
536870912 = DiffOption
DiffOptionMinimal
toEnum Int
1073741824 = DiffOption
DiffOptionShowBinary
toEnum Int
k = Int -> DiffOption
AnotherDiffOption Int
k
instance P.Ord DiffOption where
compare :: DiffOption -> DiffOption -> Ordering
compare DiffOption
a DiffOption
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffOption -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffOption
a) (DiffOption -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffOption
b)
type instance O.ParentTypes DiffOption = '[]
instance O.HasParentTypes DiffOption
foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type ::
IO GType
instance B.Types.TypedObject DiffOption where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_option_get_type
instance B.Types.BoxedFlags DiffOption
instance IsGFlag DiffOption
data DiffFormatEmailFlags =
DiffFormatEmailFlagsNone
| DiffFormatEmailFlagsExcludeSubjectPatchMarker
| AnotherDiffFormatEmailFlags Int
deriving (Int -> DiffFormatEmailFlags -> ShowS
[DiffFormatEmailFlags] -> ShowS
DiffFormatEmailFlags -> String
(Int -> DiffFormatEmailFlags -> ShowS)
-> (DiffFormatEmailFlags -> String)
-> ([DiffFormatEmailFlags] -> ShowS)
-> Show DiffFormatEmailFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFormatEmailFlags -> ShowS
showsPrec :: Int -> DiffFormatEmailFlags -> ShowS
$cshow :: DiffFormatEmailFlags -> String
show :: DiffFormatEmailFlags -> String
$cshowList :: [DiffFormatEmailFlags] -> ShowS
showList :: [DiffFormatEmailFlags] -> ShowS
Show, DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
(DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool)
-> (DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool)
-> Eq DiffFormatEmailFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
== :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
$c/= :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
/= :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
Eq)
instance P.Enum DiffFormatEmailFlags where
fromEnum :: DiffFormatEmailFlags -> Int
fromEnum DiffFormatEmailFlags
DiffFormatEmailFlagsNone = Int
0
fromEnum DiffFormatEmailFlags
DiffFormatEmailFlagsExcludeSubjectPatchMarker = Int
1
fromEnum (AnotherDiffFormatEmailFlags Int
k) = Int
k
toEnum :: Int -> DiffFormatEmailFlags
toEnum Int
0 = DiffFormatEmailFlags
DiffFormatEmailFlagsNone
toEnum Int
1 = DiffFormatEmailFlags
DiffFormatEmailFlagsExcludeSubjectPatchMarker
toEnum Int
k = Int -> DiffFormatEmailFlags
AnotherDiffFormatEmailFlags Int
k
instance P.Ord DiffFormatEmailFlags where
compare :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Ordering
compare DiffFormatEmailFlags
a DiffFormatEmailFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFormatEmailFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatEmailFlags
a) (DiffFormatEmailFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatEmailFlags
b)
type instance O.ParentTypes DiffFormatEmailFlags = '[]
instance O.HasParentTypes DiffFormatEmailFlags
foreign import ccall "ggit_diff_format_email_flags_get_type" c_ggit_diff_format_email_flags_get_type ::
IO GType
instance B.Types.TypedObject DiffFormatEmailFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_format_email_flags_get_type
instance B.Types.BoxedFlags DiffFormatEmailFlags
instance IsGFlag DiffFormatEmailFlags
data DiffFlag =
DiffFlagBinary
| DiffFlagNotBinary
| DiffFlagValidId
| AnotherDiffFlag Int
deriving (Int -> DiffFlag -> ShowS
[DiffFlag] -> ShowS
DiffFlag -> String
(Int -> DiffFlag -> ShowS)
-> (DiffFlag -> String) -> ([DiffFlag] -> ShowS) -> Show DiffFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFlag -> ShowS
showsPrec :: Int -> DiffFlag -> ShowS
$cshow :: DiffFlag -> String
show :: DiffFlag -> String
$cshowList :: [DiffFlag] -> ShowS
showList :: [DiffFlag] -> ShowS
Show, DiffFlag -> DiffFlag -> Bool
(DiffFlag -> DiffFlag -> Bool)
-> (DiffFlag -> DiffFlag -> Bool) -> Eq DiffFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFlag -> DiffFlag -> Bool
== :: DiffFlag -> DiffFlag -> Bool
$c/= :: DiffFlag -> DiffFlag -> Bool
/= :: DiffFlag -> DiffFlag -> Bool
Eq)
instance P.Enum DiffFlag where
fromEnum :: DiffFlag -> Int
fromEnum DiffFlag
DiffFlagBinary = Int
1
fromEnum DiffFlag
DiffFlagNotBinary = Int
2
fromEnum DiffFlag
DiffFlagValidId = Int
4
fromEnum (AnotherDiffFlag Int
k) = Int
k
toEnum :: Int -> DiffFlag
toEnum Int
1 = DiffFlag
DiffFlagBinary
toEnum Int
2 = DiffFlag
DiffFlagNotBinary
toEnum Int
4 = DiffFlag
DiffFlagValidId
toEnum Int
k = Int -> DiffFlag
AnotherDiffFlag Int
k
instance P.Ord DiffFlag where
compare :: DiffFlag -> DiffFlag -> Ordering
compare DiffFlag
a DiffFlag
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFlag
a) (DiffFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFlag
b)
type instance O.ParentTypes DiffFlag = '[]
instance O.HasParentTypes DiffFlag
foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type ::
IO GType
instance B.Types.TypedObject DiffFlag where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_flag_get_type
instance B.Types.BoxedFlags DiffFlag
instance IsGFlag DiffFlag
data DiffFindFlags =
DiffFindFlagsFindByConfig
| DiffFindFlagsFindRenames
| DiffFindFlagsFindRenamesFromRewrites
| DiffFindFlagsFindCopies
| DiffFindFlagsFindCopiesFromUnmodified
| DiffFindFlagsFindRewrites
| DiffFindFlagsBreakRewrites
| DiffFindFlagsFindAndBreakRewrites
| DiffFindFlagsFindForUntracked
| DiffFindFlagsFindAll
| DiffFindFlagsFindIgnoreLeadingWhitespace
| DiffFindFlagsFindIgnoreWhitespace
| DiffFindFlagsFindDontIgnoreWhitespace
| DiffFindFlagsFindExactMatchOnly
| DiffFindFlagsBreakRewritesForRenamesOnly
| DiffFindFlagsFindRemoveUnmodified
| AnotherDiffFindFlags Int
deriving (Int -> DiffFindFlags -> ShowS
[DiffFindFlags] -> ShowS
DiffFindFlags -> String
(Int -> DiffFindFlags -> ShowS)
-> (DiffFindFlags -> String)
-> ([DiffFindFlags] -> ShowS)
-> Show DiffFindFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFindFlags -> ShowS
showsPrec :: Int -> DiffFindFlags -> ShowS
$cshow :: DiffFindFlags -> String
show :: DiffFindFlags -> String
$cshowList :: [DiffFindFlags] -> ShowS
showList :: [DiffFindFlags] -> ShowS
Show, DiffFindFlags -> DiffFindFlags -> Bool
(DiffFindFlags -> DiffFindFlags -> Bool)
-> (DiffFindFlags -> DiffFindFlags -> Bool) -> Eq DiffFindFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFindFlags -> DiffFindFlags -> Bool
== :: DiffFindFlags -> DiffFindFlags -> Bool
$c/= :: DiffFindFlags -> DiffFindFlags -> Bool
/= :: DiffFindFlags -> DiffFindFlags -> Bool
Eq)
instance P.Enum DiffFindFlags where
fromEnum :: DiffFindFlags -> Int
fromEnum DiffFindFlags
DiffFindFlagsFindByConfig = Int
0
fromEnum DiffFindFlags
DiffFindFlagsFindRenames = Int
1
fromEnum DiffFindFlags
DiffFindFlagsFindRenamesFromRewrites = Int
2
fromEnum DiffFindFlags
DiffFindFlagsFindCopies = Int
4
fromEnum DiffFindFlags
DiffFindFlagsFindCopiesFromUnmodified = Int
8
fromEnum DiffFindFlags
DiffFindFlagsFindRewrites = Int
16
fromEnum DiffFindFlags
DiffFindFlagsBreakRewrites = Int
32
fromEnum DiffFindFlags
DiffFindFlagsFindAndBreakRewrites = Int
48
fromEnum DiffFindFlags
DiffFindFlagsFindForUntracked = Int
64
fromEnum DiffFindFlags
DiffFindFlagsFindAll = Int
255
fromEnum DiffFindFlags
DiffFindFlagsFindIgnoreLeadingWhitespace = Int
0
fromEnum DiffFindFlags
DiffFindFlagsFindIgnoreWhitespace = Int
4096
fromEnum DiffFindFlags
DiffFindFlagsFindDontIgnoreWhitespace = Int
8192
fromEnum DiffFindFlags
DiffFindFlagsFindExactMatchOnly = Int
16384
fromEnum DiffFindFlags
DiffFindFlagsBreakRewritesForRenamesOnly = Int
32768
fromEnum DiffFindFlags
DiffFindFlagsFindRemoveUnmodified = Int
65536
fromEnum (AnotherDiffFindFlags Int
k) = Int
k
toEnum :: Int -> DiffFindFlags
toEnum Int
0 = DiffFindFlags
DiffFindFlagsFindByConfig
toEnum Int
1 = DiffFindFlags
DiffFindFlagsFindRenames
toEnum Int
2 = DiffFindFlags
DiffFindFlagsFindRenamesFromRewrites
toEnum Int
4 = DiffFindFlags
DiffFindFlagsFindCopies
toEnum Int
8 = DiffFindFlags
DiffFindFlagsFindCopiesFromUnmodified
toEnum Int
16 = DiffFindFlags
DiffFindFlagsFindRewrites
toEnum Int
32 = DiffFindFlags
DiffFindFlagsBreakRewrites
toEnum Int
48 = DiffFindFlags
DiffFindFlagsFindAndBreakRewrites
toEnum Int
64 = DiffFindFlags
DiffFindFlagsFindForUntracked
toEnum Int
255 = DiffFindFlags
DiffFindFlagsFindAll
toEnum Int
4096 = DiffFindFlags
DiffFindFlagsFindIgnoreWhitespace
toEnum Int
8192 = DiffFindFlags
DiffFindFlagsFindDontIgnoreWhitespace
toEnum Int
16384 = DiffFindFlags
DiffFindFlagsFindExactMatchOnly
toEnum Int
32768 = DiffFindFlags
DiffFindFlagsBreakRewritesForRenamesOnly
toEnum Int
65536 = DiffFindFlags
DiffFindFlagsFindRemoveUnmodified
toEnum Int
k = Int -> DiffFindFlags
AnotherDiffFindFlags Int
k
instance P.Ord DiffFindFlags where
compare :: DiffFindFlags -> DiffFindFlags -> Ordering
compare DiffFindFlags
a DiffFindFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFindFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFindFlags
a) (DiffFindFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFindFlags
b)
type instance O.ParentTypes DiffFindFlags = '[]
instance O.HasParentTypes DiffFindFlags
foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type ::
IO GType
instance B.Types.TypedObject DiffFindFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_find_flags_get_type
instance B.Types.BoxedFlags DiffFindFlags
instance IsGFlag DiffFindFlags
data Credtype =
CredtypeUserpassPlaintext
| CredtypeSshKey
| CredtypeSshCustom
| CredtypeDefault
| CredtypeSshInteractive
| AnotherCredtype Int
deriving (Int -> Credtype -> ShowS
[Credtype] -> ShowS
Credtype -> String
(Int -> Credtype -> ShowS)
-> (Credtype -> String) -> ([Credtype] -> ShowS) -> Show Credtype
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Credtype -> ShowS
showsPrec :: Int -> Credtype -> ShowS
$cshow :: Credtype -> String
show :: Credtype -> String
$cshowList :: [Credtype] -> ShowS
showList :: [Credtype] -> ShowS
Show, Credtype -> Credtype -> Bool
(Credtype -> Credtype -> Bool)
-> (Credtype -> Credtype -> Bool) -> Eq Credtype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Credtype -> Credtype -> Bool
== :: Credtype -> Credtype -> Bool
$c/= :: Credtype -> Credtype -> Bool
/= :: Credtype -> Credtype -> Bool
Eq)
instance P.Enum Credtype where
fromEnum :: Credtype -> Int
fromEnum Credtype
CredtypeUserpassPlaintext = Int
1
fromEnum Credtype
CredtypeSshKey = Int
2
fromEnum Credtype
CredtypeSshCustom = Int
4
fromEnum Credtype
CredtypeDefault = Int
8
fromEnum Credtype
CredtypeSshInteractive = Int
16
fromEnum (AnotherCredtype Int
k) = Int
k
toEnum :: Int -> Credtype
toEnum Int
1 = Credtype
CredtypeUserpassPlaintext
toEnum Int
2 = Credtype
CredtypeSshKey
toEnum Int
4 = Credtype
CredtypeSshCustom
toEnum Int
8 = Credtype
CredtypeDefault
toEnum Int
16 = Credtype
CredtypeSshInteractive
toEnum Int
k = Int -> Credtype
AnotherCredtype Int
k
instance P.Ord Credtype where
compare :: Credtype -> Credtype -> Ordering
compare Credtype
a Credtype
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Credtype -> Int
forall a. Enum a => a -> Int
P.fromEnum Credtype
a) (Credtype -> Int
forall a. Enum a => a -> Int
P.fromEnum Credtype
b)
type instance O.ParentTypes Credtype = '[]
instance O.HasParentTypes Credtype
foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type ::
IO GType
instance B.Types.TypedObject Credtype where
glibType :: IO GType
glibType = IO GType
c_ggit_credtype_get_type
instance B.Types.BoxedFlags Credtype
instance IsGFlag Credtype
data CreateFlags =
CreateFlagsNone
| CreateFlagsForce
| AnotherCreateFlags Int
deriving (Int -> CreateFlags -> ShowS
[CreateFlags] -> ShowS
CreateFlags -> String
(Int -> CreateFlags -> ShowS)
-> (CreateFlags -> String)
-> ([CreateFlags] -> ShowS)
-> Show CreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CreateFlags -> ShowS
showsPrec :: Int -> CreateFlags -> ShowS
$cshow :: CreateFlags -> String
show :: CreateFlags -> String
$cshowList :: [CreateFlags] -> ShowS
showList :: [CreateFlags] -> ShowS
Show, CreateFlags -> CreateFlags -> Bool
(CreateFlags -> CreateFlags -> Bool)
-> (CreateFlags -> CreateFlags -> Bool) -> Eq CreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CreateFlags -> CreateFlags -> Bool
== :: CreateFlags -> CreateFlags -> Bool
$c/= :: CreateFlags -> CreateFlags -> Bool
/= :: CreateFlags -> CreateFlags -> Bool
Eq)
instance P.Enum CreateFlags where
fromEnum :: CreateFlags -> Int
fromEnum CreateFlags
CreateFlagsNone = Int
0
fromEnum CreateFlags
CreateFlagsForce = Int
1
fromEnum (AnotherCreateFlags Int
k) = Int
k
toEnum :: Int -> CreateFlags
toEnum Int
0 = CreateFlags
CreateFlagsNone
toEnum Int
1 = CreateFlags
CreateFlagsForce
toEnum Int
k = Int -> CreateFlags
AnotherCreateFlags Int
k
instance P.Ord CreateFlags where
compare :: CreateFlags -> CreateFlags -> Ordering
compare CreateFlags
a CreateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CreateFlags
a) (CreateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CreateFlags
b)
type instance O.ParentTypes CreateFlags = '[]
instance O.HasParentTypes CreateFlags
foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type ::
IO GType
instance B.Types.TypedObject CreateFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_create_flags_get_type
instance B.Types.BoxedFlags CreateFlags
instance IsGFlag CreateFlags
data CheckoutStrategy =
CheckoutStrategyNone
| CheckoutStrategySafe
| CheckoutStrategyForce
| CheckoutStrategyRecreateMissing
| CheckoutStrategyAllowConflicts
| CheckoutStrategyRemoveUntracked
| CheckoutStrategyRemoveIgnored
| CheckoutStrategyUpdateOnly
| CheckoutStrategyDontUpdateIndex
| CheckoutStrategyNoRefresh
| CheckoutStrategySkipUnmerged
| CheckoutStrategyUseOurs
| CheckoutStrategyUseTheirs
| CheckoutStrategyDisablePathspecMatch
| CheckoutStrategySkipLockedDirectories
| CheckoutStrategyDontOverwriteIgnored
| CheckoutStrategyConflictStyleMerge
| CheckoutStrategyConflictStyleDiff3
| CheckoutStrategyDontRemoveExisting
| CheckoutStrategyDontWriteIndex
| CheckoutStrategyUpdateSubmodules
| CheckoutStrategyUpdateSubmodulesIfChanged
| AnotherCheckoutStrategy Int
deriving (Int -> CheckoutStrategy -> ShowS
[CheckoutStrategy] -> ShowS
CheckoutStrategy -> String
(Int -> CheckoutStrategy -> ShowS)
-> (CheckoutStrategy -> String)
-> ([CheckoutStrategy] -> ShowS)
-> Show CheckoutStrategy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckoutStrategy -> ShowS
showsPrec :: Int -> CheckoutStrategy -> ShowS
$cshow :: CheckoutStrategy -> String
show :: CheckoutStrategy -> String
$cshowList :: [CheckoutStrategy] -> ShowS
showList :: [CheckoutStrategy] -> ShowS
Show, CheckoutStrategy -> CheckoutStrategy -> Bool
(CheckoutStrategy -> CheckoutStrategy -> Bool)
-> (CheckoutStrategy -> CheckoutStrategy -> Bool)
-> Eq CheckoutStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckoutStrategy -> CheckoutStrategy -> Bool
== :: CheckoutStrategy -> CheckoutStrategy -> Bool
$c/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
Eq)
instance P.Enum CheckoutStrategy where
fromEnum :: CheckoutStrategy -> Int
fromEnum CheckoutStrategy
CheckoutStrategyNone = Int
0
fromEnum CheckoutStrategy
CheckoutStrategySafe = Int
1
fromEnum CheckoutStrategy
CheckoutStrategyForce = Int
2
fromEnum CheckoutStrategy
CheckoutStrategyRecreateMissing = Int
4
fromEnum CheckoutStrategy
CheckoutStrategyAllowConflicts = Int
16
fromEnum CheckoutStrategy
CheckoutStrategyRemoveUntracked = Int
32
fromEnum CheckoutStrategy
CheckoutStrategyRemoveIgnored = Int
64
fromEnum CheckoutStrategy
CheckoutStrategyUpdateOnly = Int
128
fromEnum CheckoutStrategy
CheckoutStrategyDontUpdateIndex = Int
256
fromEnum CheckoutStrategy
CheckoutStrategyNoRefresh = Int
512
fromEnum CheckoutStrategy
CheckoutStrategySkipUnmerged = Int
1024
fromEnum CheckoutStrategy
CheckoutStrategyUseOurs = Int
2048
fromEnum CheckoutStrategy
CheckoutStrategyUseTheirs = Int
4096
fromEnum CheckoutStrategy
CheckoutStrategyDisablePathspecMatch = Int
8192
fromEnum CheckoutStrategy
CheckoutStrategySkipLockedDirectories = Int
262144
fromEnum CheckoutStrategy
CheckoutStrategyDontOverwriteIgnored = Int
524288
fromEnum CheckoutStrategy
CheckoutStrategyConflictStyleMerge = Int
1048576
fromEnum CheckoutStrategy
CheckoutStrategyConflictStyleDiff3 = Int
2097152
fromEnum CheckoutStrategy
CheckoutStrategyDontRemoveExisting = Int
4194304
fromEnum CheckoutStrategy
CheckoutStrategyDontWriteIndex = Int
8388608
fromEnum CheckoutStrategy
CheckoutStrategyUpdateSubmodules = Int
65536
fromEnum CheckoutStrategy
CheckoutStrategyUpdateSubmodulesIfChanged = Int
131072
fromEnum (AnotherCheckoutStrategy Int
k) = Int
k
toEnum :: Int -> CheckoutStrategy
toEnum Int
0 = CheckoutStrategy
CheckoutStrategyNone
toEnum Int
1 = CheckoutStrategy
CheckoutStrategySafe
toEnum Int
2 = CheckoutStrategy
CheckoutStrategyForce
toEnum Int
4 = CheckoutStrategy
CheckoutStrategyRecreateMissing
toEnum Int
16 = CheckoutStrategy
CheckoutStrategyAllowConflicts
toEnum Int
32 = CheckoutStrategy
CheckoutStrategyRemoveUntracked
toEnum Int
64 = CheckoutStrategy
CheckoutStrategyRemoveIgnored
toEnum Int
128 = CheckoutStrategy
CheckoutStrategyUpdateOnly
toEnum Int
256 = CheckoutStrategy
CheckoutStrategyDontUpdateIndex
toEnum Int
512 = CheckoutStrategy
CheckoutStrategyNoRefresh
toEnum Int
1024 = CheckoutStrategy
CheckoutStrategySkipUnmerged
toEnum Int
2048 = CheckoutStrategy
CheckoutStrategyUseOurs
toEnum Int
4096 = CheckoutStrategy
CheckoutStrategyUseTheirs
toEnum Int
8192 = CheckoutStrategy
CheckoutStrategyDisablePathspecMatch
toEnum Int
262144 = CheckoutStrategy
CheckoutStrategySkipLockedDirectories
toEnum Int
524288 = CheckoutStrategy
CheckoutStrategyDontOverwriteIgnored
toEnum Int
1048576 = CheckoutStrategy
CheckoutStrategyConflictStyleMerge
toEnum Int
2097152 = CheckoutStrategy
CheckoutStrategyConflictStyleDiff3
toEnum Int
4194304 = CheckoutStrategy
CheckoutStrategyDontRemoveExisting
toEnum Int
8388608 = CheckoutStrategy
CheckoutStrategyDontWriteIndex
toEnum Int
65536 = CheckoutStrategy
CheckoutStrategyUpdateSubmodules
toEnum Int
131072 = CheckoutStrategy
CheckoutStrategyUpdateSubmodulesIfChanged
toEnum Int
k = Int -> CheckoutStrategy
AnotherCheckoutStrategy Int
k
instance P.Ord CheckoutStrategy where
compare :: CheckoutStrategy -> CheckoutStrategy -> Ordering
compare CheckoutStrategy
a CheckoutStrategy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CheckoutStrategy -> Int
forall a. Enum a => a -> Int
P.fromEnum CheckoutStrategy
a) (CheckoutStrategy -> Int
forall a. Enum a => a -> Int
P.fromEnum CheckoutStrategy
b)
type instance O.ParentTypes CheckoutStrategy = '[]
instance O.HasParentTypes CheckoutStrategy
foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type ::
IO GType
instance B.Types.TypedObject CheckoutStrategy where
glibType :: IO GType
glibType = IO GType
c_ggit_checkout_strategy_get_type
instance B.Types.BoxedFlags CheckoutStrategy
instance IsGFlag CheckoutStrategy
data CheckoutNotifyFlags =
CheckoutNotifyFlagsNone
| CheckoutNotifyFlagsConflict
| CheckoutNotifyFlagsDirty
| CheckoutNotifyFlagsUpdated
| CheckoutNotifyFlagsUntracked
| CheckoutNotifyFlagsIgnored
| CheckoutNotifyFlagsAll
| AnotherCheckoutNotifyFlags Int
deriving (Int -> CheckoutNotifyFlags -> ShowS
[CheckoutNotifyFlags] -> ShowS
CheckoutNotifyFlags -> String
(Int -> CheckoutNotifyFlags -> ShowS)
-> (CheckoutNotifyFlags -> String)
-> ([CheckoutNotifyFlags] -> ShowS)
-> Show CheckoutNotifyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckoutNotifyFlags -> ShowS
showsPrec :: Int -> CheckoutNotifyFlags -> ShowS
$cshow :: CheckoutNotifyFlags -> String
show :: CheckoutNotifyFlags -> String
$cshowList :: [CheckoutNotifyFlags] -> ShowS
showList :: [CheckoutNotifyFlags] -> ShowS
Show, CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
(CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> (CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> Eq CheckoutNotifyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
$c/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
Eq)
instance P.Enum CheckoutNotifyFlags where
fromEnum :: CheckoutNotifyFlags -> Int
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsNone = Int
0
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsConflict = Int
1
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsDirty = Int
2
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsUpdated = Int
4
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsUntracked = Int
8
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsIgnored = Int
16
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsAll = Int
65535
fromEnum (AnotherCheckoutNotifyFlags Int
k) = Int
k
toEnum :: Int -> CheckoutNotifyFlags
toEnum Int
0 = CheckoutNotifyFlags
CheckoutNotifyFlagsNone
toEnum Int
1 = CheckoutNotifyFlags
CheckoutNotifyFlagsConflict
toEnum Int
2 = CheckoutNotifyFlags
CheckoutNotifyFlagsDirty
toEnum Int
4 = CheckoutNotifyFlags
CheckoutNotifyFlagsUpdated
toEnum Int
8 = CheckoutNotifyFlags
CheckoutNotifyFlagsUntracked
toEnum Int
16 = CheckoutNotifyFlags
CheckoutNotifyFlagsIgnored
toEnum Int
65535 = CheckoutNotifyFlags
CheckoutNotifyFlagsAll
toEnum Int
k = Int -> CheckoutNotifyFlags
AnotherCheckoutNotifyFlags Int
k
instance P.Ord CheckoutNotifyFlags where
compare :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Ordering
compare CheckoutNotifyFlags
a CheckoutNotifyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CheckoutNotifyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CheckoutNotifyFlags
a) (CheckoutNotifyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CheckoutNotifyFlags
b)
type instance O.ParentTypes CheckoutNotifyFlags = '[]
instance O.HasParentTypes CheckoutNotifyFlags
foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type ::
IO GType
instance B.Types.TypedObject CheckoutNotifyFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_checkout_notify_flags_get_type
instance B.Types.BoxedFlags CheckoutNotifyFlags
instance IsGFlag CheckoutNotifyFlags
data BlameFlags =
BlameFlagsNormal
| BlameFlagsTrackCopiesSameFile
| AnotherBlameFlags Int
deriving (Int -> BlameFlags -> ShowS
[BlameFlags] -> ShowS
BlameFlags -> String
(Int -> BlameFlags -> ShowS)
-> (BlameFlags -> String)
-> ([BlameFlags] -> ShowS)
-> Show BlameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlameFlags -> ShowS
showsPrec :: Int -> BlameFlags -> ShowS
$cshow :: BlameFlags -> String
show :: BlameFlags -> String
$cshowList :: [BlameFlags] -> ShowS
showList :: [BlameFlags] -> ShowS
Show, BlameFlags -> BlameFlags -> Bool
(BlameFlags -> BlameFlags -> Bool)
-> (BlameFlags -> BlameFlags -> Bool) -> Eq BlameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlameFlags -> BlameFlags -> Bool
== :: BlameFlags -> BlameFlags -> Bool
$c/= :: BlameFlags -> BlameFlags -> Bool
/= :: BlameFlags -> BlameFlags -> Bool
Eq)
instance P.Enum BlameFlags where
fromEnum :: BlameFlags -> Int
fromEnum BlameFlags
BlameFlagsNormal = Int
0
fromEnum BlameFlags
BlameFlagsTrackCopiesSameFile = Int
1
fromEnum (AnotherBlameFlags Int
k) = Int
k
toEnum :: Int -> BlameFlags
toEnum Int
0 = BlameFlags
BlameFlagsNormal
toEnum Int
1 = BlameFlags
BlameFlagsTrackCopiesSameFile
toEnum Int
k = Int -> BlameFlags
AnotherBlameFlags Int
k
instance P.Ord BlameFlags where
compare :: BlameFlags -> BlameFlags -> Ordering
compare BlameFlags
a BlameFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BlameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BlameFlags
a) (BlameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BlameFlags
b)
type instance O.ParentTypes BlameFlags = '[]
instance O.HasParentTypes BlameFlags
foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type ::
IO GType
instance B.Types.TypedObject BlameFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_blame_flags_get_type
instance B.Types.BoxedFlags BlameFlags
instance IsGFlag BlameFlags
data AttributeCheckFlags =
AttributeCheckFlagsFileThenIndex
| AttributeCheckFlagsIndexThenFile
| AttributeCheckFlagsIndexOnly
| AttributeCheckFlagsNoSystem
| AnotherAttributeCheckFlags Int
deriving (Int -> AttributeCheckFlags -> ShowS
[AttributeCheckFlags] -> ShowS
AttributeCheckFlags -> String
(Int -> AttributeCheckFlags -> ShowS)
-> (AttributeCheckFlags -> String)
-> ([AttributeCheckFlags] -> ShowS)
-> Show AttributeCheckFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AttributeCheckFlags -> ShowS
showsPrec :: Int -> AttributeCheckFlags -> ShowS
$cshow :: AttributeCheckFlags -> String
show :: AttributeCheckFlags -> String
$cshowList :: [AttributeCheckFlags] -> ShowS
showList :: [AttributeCheckFlags] -> ShowS
Show, AttributeCheckFlags -> AttributeCheckFlags -> Bool
(AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> (AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> Eq AttributeCheckFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
$c/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
Eq)
instance P.Enum AttributeCheckFlags where
fromEnum :: AttributeCheckFlags -> Int
fromEnum AttributeCheckFlags
AttributeCheckFlagsFileThenIndex = Int
0
fromEnum AttributeCheckFlags
AttributeCheckFlagsIndexThenFile = Int
1
fromEnum AttributeCheckFlags
AttributeCheckFlagsIndexOnly = Int
2
fromEnum AttributeCheckFlags
AttributeCheckFlagsNoSystem = Int
4
fromEnum (AnotherAttributeCheckFlags Int
k) = Int
k
toEnum :: Int -> AttributeCheckFlags
toEnum Int
0 = AttributeCheckFlags
AttributeCheckFlagsFileThenIndex
toEnum Int
1 = AttributeCheckFlags
AttributeCheckFlagsIndexThenFile
toEnum Int
2 = AttributeCheckFlags
AttributeCheckFlagsIndexOnly
toEnum Int
4 = AttributeCheckFlags
AttributeCheckFlagsNoSystem
toEnum Int
k = Int -> AttributeCheckFlags
AnotherAttributeCheckFlags Int
k
instance P.Ord AttributeCheckFlags where
compare :: AttributeCheckFlags -> AttributeCheckFlags -> Ordering
compare AttributeCheckFlags
a AttributeCheckFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AttributeCheckFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AttributeCheckFlags
a) (AttributeCheckFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AttributeCheckFlags
b)
type instance O.ParentTypes AttributeCheckFlags = '[]
instance O.HasParentTypes AttributeCheckFlags
foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type ::
IO GType
instance B.Types.TypedObject AttributeCheckFlags where
glibType :: IO GType
glibType = IO GType
c_ggit_attribute_check_flags_get_type
instance B.Types.BoxedFlags AttributeCheckFlags
instance IsGFlag AttributeCheckFlags