#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.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
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
showList :: [SubmoduleStatus] -> ShowS
$cshowList :: [SubmoduleStatus] -> ShowS
show :: SubmoduleStatus -> String
$cshow :: SubmoduleStatus -> String
showsPrec :: Int -> SubmoduleStatus -> ShowS
$cshowsPrec :: Int -> SubmoduleStatus -> ShowS
Show, SubmoduleStatus -> SubmoduleStatus -> Bool
(SubmoduleStatus -> SubmoduleStatus -> Bool)
-> (SubmoduleStatus -> SubmoduleStatus -> Bool)
-> Eq SubmoduleStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
$c/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
== :: SubmoduleStatus -> SubmoduleStatus -> Bool
$c== :: SubmoduleStatus -> SubmoduleStatus -> Bool
Eq)
instance P.Enum SubmoduleStatus where
fromEnum :: SubmoduleStatus -> Int
fromEnum SubmoduleStatusInHead = 1
fromEnum SubmoduleStatusInIndex = 2
fromEnum SubmoduleStatusInConfig = 4
fromEnum SubmoduleStatusInWd = 8
fromEnum SubmoduleStatusIndexAdded = 16
fromEnum SubmoduleStatusIndexDeleted = 32
fromEnum SubmoduleStatusIndexModified = 64
fromEnum SubmoduleStatusWdUninitialized = 128
fromEnum SubmoduleStatusWdAdded = 256
fromEnum SubmoduleStatusWdDeleted = 512
fromEnum SubmoduleStatusWdModified = 1024
fromEnum SubmoduleStatusWdIndexModified = 2048
fromEnum SubmoduleStatusWdWdModified = 4096
fromEnum SubmoduleStatusWdUntracked = 8192
fromEnum (AnotherSubmoduleStatus k :: Int
k) = Int
k
toEnum :: Int -> SubmoduleStatus
toEnum 1 = SubmoduleStatus
SubmoduleStatusInHead
toEnum 2 = SubmoduleStatus
SubmoduleStatusInIndex
toEnum 4 = SubmoduleStatus
SubmoduleStatusInConfig
toEnum 8 = SubmoduleStatus
SubmoduleStatusInWd
toEnum 16 = SubmoduleStatus
SubmoduleStatusIndexAdded
toEnum 32 = SubmoduleStatus
SubmoduleStatusIndexDeleted
toEnum 64 = SubmoduleStatus
SubmoduleStatusIndexModified
toEnum 128 = SubmoduleStatus
SubmoduleStatusWdUninitialized
toEnum 256 = SubmoduleStatus
SubmoduleStatusWdAdded
toEnum 512 = SubmoduleStatus
SubmoduleStatusWdDeleted
toEnum 1024 = SubmoduleStatus
SubmoduleStatusWdModified
toEnum 2048 = SubmoduleStatus
SubmoduleStatusWdIndexModified
toEnum 4096 = SubmoduleStatus
SubmoduleStatusWdWdModified
toEnum 8192 = SubmoduleStatus
SubmoduleStatusWdUntracked
toEnum k :: Int
k = Int -> SubmoduleStatus
AnotherSubmoduleStatus Int
k
instance P.Ord SubmoduleStatus where
compare :: SubmoduleStatus -> SubmoduleStatus -> Ordering
compare a :: SubmoduleStatus
a b :: 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
showList :: [StatusOption] -> ShowS
$cshowList :: [StatusOption] -> ShowS
show :: StatusOption -> String
$cshow :: StatusOption -> String
showsPrec :: Int -> StatusOption -> ShowS
$cshowsPrec :: Int -> StatusOption -> ShowS
Show, StatusOption -> StatusOption -> Bool
(StatusOption -> StatusOption -> Bool)
-> (StatusOption -> StatusOption -> Bool) -> Eq StatusOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusOption -> StatusOption -> Bool
$c/= :: StatusOption -> StatusOption -> Bool
== :: StatusOption -> StatusOption -> Bool
$c== :: StatusOption -> StatusOption -> Bool
Eq)
instance P.Enum StatusOption where
fromEnum :: StatusOption -> Int
fromEnum StatusOptionIncludeUntracked = 1
fromEnum StatusOptionIncludeIgnored = 2
fromEnum StatusOptionIncludeUnmodified = 4
fromEnum StatusOptionExcludeSubmodules = 8
fromEnum StatusOptionRecurseUntrackedDirs = 16
fromEnum StatusOptionDisablePathspecMatch = 32
fromEnum StatusOptionRecurseIgnoredDirs = 64
fromEnum StatusOptionRenamesHeadToIndex = 128
fromEnum StatusOptionRenamesIndexToWorkdir = 256
fromEnum StatusOptionSortCaseSensitively = 512
fromEnum StatusOptionSortCaseInsensitively = 1024
fromEnum StatusOptionDefault = 19
fromEnum (AnotherStatusOption k :: Int
k) = Int
k
toEnum :: Int -> StatusOption
toEnum 1 = StatusOption
StatusOptionIncludeUntracked
toEnum 2 = StatusOption
StatusOptionIncludeIgnored
toEnum 4 = StatusOption
StatusOptionIncludeUnmodified
toEnum 8 = StatusOption
StatusOptionExcludeSubmodules
toEnum 16 = StatusOption
StatusOptionRecurseUntrackedDirs
toEnum 32 = StatusOption
StatusOptionDisablePathspecMatch
toEnum 64 = StatusOption
StatusOptionRecurseIgnoredDirs
toEnum 128 = StatusOption
StatusOptionRenamesHeadToIndex
toEnum 256 = StatusOption
StatusOptionRenamesIndexToWorkdir
toEnum 512 = StatusOption
StatusOptionSortCaseSensitively
toEnum 1024 = StatusOption
StatusOptionSortCaseInsensitively
toEnum 19 = StatusOption
StatusOptionDefault
toEnum k :: Int
k = Int -> StatusOption
AnotherStatusOption Int
k
instance P.Ord StatusOption where
compare :: StatusOption -> StatusOption -> Ordering
compare a :: StatusOption
a b :: 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
| StatusFlagsIgnored
| 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
showList :: [StatusFlags] -> ShowS
$cshowList :: [StatusFlags] -> ShowS
show :: StatusFlags -> String
$cshow :: StatusFlags -> String
showsPrec :: Int -> StatusFlags -> ShowS
$cshowsPrec :: Int -> StatusFlags -> ShowS
Show, StatusFlags -> StatusFlags -> Bool
(StatusFlags -> StatusFlags -> Bool)
-> (StatusFlags -> StatusFlags -> Bool) -> Eq StatusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusFlags -> StatusFlags -> Bool
$c/= :: StatusFlags -> StatusFlags -> Bool
== :: StatusFlags -> StatusFlags -> Bool
$c== :: StatusFlags -> StatusFlags -> Bool
Eq)
instance P.Enum StatusFlags where
fromEnum :: StatusFlags -> Int
fromEnum StatusFlagsCurrent = 0
fromEnum StatusFlagsIndexNew = 1
fromEnum StatusFlagsIndexModified = 2
fromEnum StatusFlagsIndexDeleted = 4
fromEnum StatusFlagsIndexRenamed = 8
fromEnum StatusFlagsIndexTypechange = 16
fromEnum StatusFlagsWorkingTreeNew = 128
fromEnum StatusFlagsWorkingTreeModified = 256
fromEnum StatusFlagsWorkingTreeDeleted = 512
fromEnum StatusFlagsWorkingTreeTypechange = 1024
fromEnum StatusFlagsIgnored = 16384
fromEnum (AnotherStatusFlags k :: Int
k) = Int
k
toEnum :: Int -> StatusFlags
toEnum 0 = StatusFlags
StatusFlagsCurrent
toEnum 1 = StatusFlags
StatusFlagsIndexNew
toEnum 2 = StatusFlags
StatusFlagsIndexModified
toEnum 4 = StatusFlags
StatusFlagsIndexDeleted
toEnum 8 = StatusFlags
StatusFlagsIndexRenamed
toEnum 16 = StatusFlags
StatusFlagsIndexTypechange
toEnum 128 = StatusFlags
StatusFlagsWorkingTreeNew
toEnum 256 = StatusFlags
StatusFlagsWorkingTreeModified
toEnum 512 = StatusFlags
StatusFlagsWorkingTreeDeleted
toEnum 1024 = StatusFlags
StatusFlagsWorkingTreeTypechange
toEnum 16384 = StatusFlags
StatusFlagsIgnored
toEnum k :: Int
k = Int -> StatusFlags
AnotherStatusFlags Int
k
instance P.Ord StatusFlags where
compare :: StatusFlags -> StatusFlags -> Ordering
compare a :: StatusFlags
a b :: 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
showList :: [StashFlags] -> ShowS
$cshowList :: [StashFlags] -> ShowS
show :: StashFlags -> String
$cshow :: StashFlags -> String
showsPrec :: Int -> StashFlags -> ShowS
$cshowsPrec :: Int -> StashFlags -> ShowS
Show, StashFlags -> StashFlags -> Bool
(StashFlags -> StashFlags -> Bool)
-> (StashFlags -> StashFlags -> Bool) -> Eq StashFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StashFlags -> StashFlags -> Bool
$c/= :: StashFlags -> StashFlags -> Bool
== :: StashFlags -> StashFlags -> Bool
$c== :: StashFlags -> StashFlags -> Bool
Eq)
instance P.Enum StashFlags where
fromEnum :: StashFlags -> Int
fromEnum StashFlagsDefault = 0
fromEnum StashFlagsKeepIndex = 1
fromEnum StashFlagsIncludeUntracked = 2
fromEnum StashFlagsIncludeIgnored = 4
fromEnum (AnotherStashFlags k :: Int
k) = Int
k
toEnum :: Int -> StashFlags
toEnum 0 = StashFlags
StashFlagsDefault
toEnum 1 = StashFlags
StashFlagsKeepIndex
toEnum 2 = StashFlags
StashFlagsIncludeUntracked
toEnum 4 = StashFlags
StashFlagsIncludeIgnored
toEnum k :: Int
k = Int -> StashFlags
AnotherStashFlags Int
k
instance P.Ord StashFlags where
compare :: StashFlags -> StashFlags -> Ordering
compare a :: StashFlags
a b :: 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
showList :: [SortMode] -> ShowS
$cshowList :: [SortMode] -> ShowS
show :: SortMode -> String
$cshow :: SortMode -> String
showsPrec :: Int -> SortMode -> ShowS
$cshowsPrec :: Int -> SortMode -> ShowS
Show, SortMode -> SortMode -> Bool
(SortMode -> SortMode -> Bool)
-> (SortMode -> SortMode -> Bool) -> Eq SortMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortMode -> SortMode -> Bool
$c/= :: SortMode -> SortMode -> Bool
== :: SortMode -> SortMode -> Bool
$c== :: SortMode -> SortMode -> Bool
Eq)
instance P.Enum SortMode where
fromEnum :: SortMode -> Int
fromEnum SortModeNone = 0
fromEnum SortModeTopological = 1
fromEnum SortModeTime = 2
fromEnum SortModeReverse = 4
fromEnum (AnotherSortMode k :: Int
k) = Int
k
toEnum :: Int -> SortMode
toEnum 0 = SortMode
SortModeNone
toEnum 1 = SortMode
SortModeTopological
toEnum 2 = SortMode
SortModeTime
toEnum 4 = SortMode
SortModeReverse
toEnum k :: Int
k = Int -> SortMode
AnotherSortMode Int
k
instance P.Ord SortMode where
compare :: SortMode -> SortMode -> Ordering
compare a :: SortMode
a b :: 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
showList :: [MergeFlags] -> ShowS
$cshowList :: [MergeFlags] -> ShowS
show :: MergeFlags -> String
$cshow :: MergeFlags -> String
showsPrec :: Int -> MergeFlags -> ShowS
$cshowsPrec :: Int -> MergeFlags -> ShowS
Show, MergeFlags -> MergeFlags -> Bool
(MergeFlags -> MergeFlags -> Bool)
-> (MergeFlags -> MergeFlags -> Bool) -> Eq MergeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MergeFlags -> MergeFlags -> Bool
$c/= :: MergeFlags -> MergeFlags -> Bool
== :: MergeFlags -> MergeFlags -> Bool
$c== :: MergeFlags -> MergeFlags -> Bool
Eq)
instance P.Enum MergeFlags where
fromEnum :: MergeFlags -> Int
fromEnum MergeFlagsFindRenames = 1
fromEnum MergeFlagsFailOnConflict = 2
fromEnum MergeFlagsSkipReuc = 4
fromEnum MergeFlagsNoRecursive = 8
fromEnum (AnotherMergeFlags k :: Int
k) = Int
k
toEnum :: Int -> MergeFlags
toEnum 1 = MergeFlags
MergeFlagsFindRenames
toEnum 2 = MergeFlags
MergeFlagsFailOnConflict
toEnum 4 = MergeFlags
MergeFlagsSkipReuc
toEnum 8 = MergeFlags
MergeFlagsNoRecursive
toEnum k :: Int
k = Int -> MergeFlags
AnotherMergeFlags Int
k
instance P.Ord MergeFlags where
compare :: MergeFlags -> MergeFlags -> Ordering
compare a :: MergeFlags
a b :: 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
showList :: [MergeFileFlags] -> ShowS
$cshowList :: [MergeFileFlags] -> ShowS
show :: MergeFileFlags -> String
$cshow :: MergeFileFlags -> String
showsPrec :: Int -> MergeFileFlags -> ShowS
$cshowsPrec :: Int -> MergeFileFlags -> ShowS
Show, MergeFileFlags -> MergeFileFlags -> Bool
(MergeFileFlags -> MergeFileFlags -> Bool)
-> (MergeFileFlags -> MergeFileFlags -> Bool) -> Eq MergeFileFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MergeFileFlags -> MergeFileFlags -> Bool
$c/= :: MergeFileFlags -> MergeFileFlags -> Bool
== :: MergeFileFlags -> MergeFileFlags -> Bool
$c== :: MergeFileFlags -> MergeFileFlags -> Bool
Eq)
instance P.Enum MergeFileFlags where
fromEnum :: MergeFileFlags -> Int
fromEnum MergeFileFlagsDefault = 0
fromEnum MergeFileFlagsStyleMerge = 1
fromEnum MergeFileFlagsStyleDiff3 = 2
fromEnum MergeFileFlagsSimplifyAlnum = 4
fromEnum MergeFileFlagsIgnoreWhitespace = 8
fromEnum MergeFileFlagsIgnoreWhitespaceChange = 16
fromEnum MergeFileFlagsIgnoreWhitespaceEol = 32
fromEnum MergeFileFlagsDiffPatience = 64
fromEnum MergeFileFlagsDiffMinimal = 128
fromEnum (AnotherMergeFileFlags k :: Int
k) = Int
k
toEnum :: Int -> MergeFileFlags
toEnum 0 = MergeFileFlags
MergeFileFlagsDefault
toEnum 1 = MergeFileFlags
MergeFileFlagsStyleMerge
toEnum 2 = MergeFileFlags
MergeFileFlagsStyleDiff3
toEnum 4 = MergeFileFlags
MergeFileFlagsSimplifyAlnum
toEnum 8 = MergeFileFlags
MergeFileFlagsIgnoreWhitespace
toEnum 16 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceChange
toEnum 32 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceEol
toEnum 64 = MergeFileFlags
MergeFileFlagsDiffPatience
toEnum 128 = MergeFileFlags
MergeFileFlagsDiffMinimal
toEnum k :: Int
k = Int -> MergeFileFlags
AnotherMergeFileFlags Int
k
instance P.Ord MergeFileFlags where
compare :: MergeFileFlags -> MergeFileFlags -> Ordering
compare a :: MergeFileFlags
a b :: 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
showList :: [FeatureFlags] -> ShowS
$cshowList :: [FeatureFlags] -> ShowS
show :: FeatureFlags -> String
$cshow :: FeatureFlags -> String
showsPrec :: Int -> FeatureFlags -> ShowS
$cshowsPrec :: Int -> FeatureFlags -> ShowS
Show, FeatureFlags -> FeatureFlags -> Bool
(FeatureFlags -> FeatureFlags -> Bool)
-> (FeatureFlags -> FeatureFlags -> Bool) -> Eq FeatureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FeatureFlags -> FeatureFlags -> Bool
$c/= :: FeatureFlags -> FeatureFlags -> Bool
== :: FeatureFlags -> FeatureFlags -> Bool
$c== :: FeatureFlags -> FeatureFlags -> Bool
Eq)
instance P.Enum FeatureFlags where
fromEnum :: FeatureFlags -> Int
fromEnum FeatureFlagsThreads = 1
fromEnum FeatureFlagsHttps = 2
fromEnum FeatureFlagsSsh = 4
fromEnum (AnotherFeatureFlags k :: Int
k) = Int
k
toEnum :: Int -> FeatureFlags
toEnum 1 = FeatureFlags
FeatureFlagsThreads
toEnum 2 = FeatureFlags
FeatureFlagsHttps
toEnum 4 = FeatureFlags
FeatureFlagsSsh
toEnum k :: Int
k = Int -> FeatureFlags
AnotherFeatureFlags Int
k
instance P.Ord FeatureFlags where
compare :: FeatureFlags -> FeatureFlags -> Ordering
compare a :: FeatureFlags
a b :: 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
showList :: [DiffOption] -> ShowS
$cshowList :: [DiffOption] -> ShowS
show :: DiffOption -> String
$cshow :: DiffOption -> String
showsPrec :: Int -> DiffOption -> ShowS
$cshowsPrec :: Int -> DiffOption -> ShowS
Show, DiffOption -> DiffOption -> Bool
(DiffOption -> DiffOption -> Bool)
-> (DiffOption -> DiffOption -> Bool) -> Eq DiffOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffOption -> DiffOption -> Bool
$c/= :: DiffOption -> DiffOption -> Bool
== :: DiffOption -> DiffOption -> Bool
$c== :: DiffOption -> DiffOption -> Bool
Eq)
instance P.Enum DiffOption where
fromEnum :: DiffOption -> Int
fromEnum DiffOptionNormal = 0
fromEnum DiffOptionReverse = 1
fromEnum DiffOptionIncludeIgnored = 2
fromEnum DiffOptionRecurseIgnoredDirs = 4
fromEnum DiffOptionIncludeUntracked = 8
fromEnum DiffOptionRecurseUntrackedDirs = 16
fromEnum DiffOptionIncludeUnmodified = 32
fromEnum DiffOptionIncludeTypechange = 64
fromEnum DiffOptionIncludeTypechangeTrees = 128
fromEnum DiffOptionIgnoreFileMode = 256
fromEnum DiffOptionIgnoreSubmodules = 512
fromEnum DiffOptionIgnoreCase = 1024
fromEnum DiffOptionDisablePathspecMatch = 4096
fromEnum DiffOptionSkipBinaryCheck = 8192
fromEnum DiffOptionEnableFastUntrackedDirs = 16384
fromEnum DiffOptionForceText = 1048576
fromEnum DiffOptionForceBinary = 2097152
fromEnum DiffOptionIgnoreWhitespace = 4194304
fromEnum DiffOptionIgnoreWhitespaceChange = 8388608
fromEnum DiffOptionIgnoreWhitespaceEol = 16777216
fromEnum DiffOptionShowUntrackedContent = 33554432
fromEnum DiffOptionShowUnmodified = 67108864
fromEnum DiffOptionPatience = 268435456
fromEnum DiffOptionMinimal = 536870912
fromEnum DiffOptionShowBinary = 1073741824
fromEnum (AnotherDiffOption k :: Int
k) = Int
k
toEnum :: Int -> DiffOption
toEnum 0 = DiffOption
DiffOptionNormal
toEnum 1 = DiffOption
DiffOptionReverse
toEnum 2 = DiffOption
DiffOptionIncludeIgnored
toEnum 4 = DiffOption
DiffOptionRecurseIgnoredDirs
toEnum 8 = DiffOption
DiffOptionIncludeUntracked
toEnum 16 = DiffOption
DiffOptionRecurseUntrackedDirs
toEnum 32 = DiffOption
DiffOptionIncludeUnmodified
toEnum 64 = DiffOption
DiffOptionIncludeTypechange
toEnum 128 = DiffOption
DiffOptionIncludeTypechangeTrees
toEnum 256 = DiffOption
DiffOptionIgnoreFileMode
toEnum 512 = DiffOption
DiffOptionIgnoreSubmodules
toEnum 1024 = DiffOption
DiffOptionIgnoreCase
toEnum 4096 = DiffOption
DiffOptionDisablePathspecMatch
toEnum 8192 = DiffOption
DiffOptionSkipBinaryCheck
toEnum 16384 = DiffOption
DiffOptionEnableFastUntrackedDirs
toEnum 1048576 = DiffOption
DiffOptionForceText
toEnum 2097152 = DiffOption
DiffOptionForceBinary
toEnum 4194304 = DiffOption
DiffOptionIgnoreWhitespace
toEnum 8388608 = DiffOption
DiffOptionIgnoreWhitespaceChange
toEnum 16777216 = DiffOption
DiffOptionIgnoreWhitespaceEol
toEnum 33554432 = DiffOption
DiffOptionShowUntrackedContent
toEnum 67108864 = DiffOption
DiffOptionShowUnmodified
toEnum 268435456 = DiffOption
DiffOptionPatience
toEnum 536870912 = DiffOption
DiffOptionMinimal
toEnum 1073741824 = DiffOption
DiffOptionShowBinary
toEnum k :: Int
k = Int -> DiffOption
AnotherDiffOption Int
k
instance P.Ord DiffOption where
compare :: DiffOption -> DiffOption -> Ordering
compare a :: DiffOption
a b :: 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
showList :: [DiffFormatEmailFlags] -> ShowS
$cshowList :: [DiffFormatEmailFlags] -> ShowS
show :: DiffFormatEmailFlags -> String
$cshow :: DiffFormatEmailFlags -> String
showsPrec :: Int -> DiffFormatEmailFlags -> ShowS
$cshowsPrec :: Int -> DiffFormatEmailFlags -> ShowS
Show, DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
(DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool)
-> (DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool)
-> Eq DiffFormatEmailFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
$c/= :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
== :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
$c== :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Bool
Eq)
instance P.Enum DiffFormatEmailFlags where
fromEnum :: DiffFormatEmailFlags -> Int
fromEnum DiffFormatEmailFlagsNone = 0
fromEnum DiffFormatEmailFlagsExcludeSubjectPatchMarker = 1
fromEnum (AnotherDiffFormatEmailFlags k :: Int
k) = Int
k
toEnum :: Int -> DiffFormatEmailFlags
toEnum 0 = DiffFormatEmailFlags
DiffFormatEmailFlagsNone
toEnum 1 = DiffFormatEmailFlags
DiffFormatEmailFlagsExcludeSubjectPatchMarker
toEnum k :: Int
k = Int -> DiffFormatEmailFlags
AnotherDiffFormatEmailFlags Int
k
instance P.Ord DiffFormatEmailFlags where
compare :: DiffFormatEmailFlags -> DiffFormatEmailFlags -> Ordering
compare a :: DiffFormatEmailFlags
a b :: 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
showList :: [DiffFlag] -> ShowS
$cshowList :: [DiffFlag] -> ShowS
show :: DiffFlag -> String
$cshow :: DiffFlag -> String
showsPrec :: Int -> DiffFlag -> ShowS
$cshowsPrec :: Int -> DiffFlag -> ShowS
Show, DiffFlag -> DiffFlag -> Bool
(DiffFlag -> DiffFlag -> Bool)
-> (DiffFlag -> DiffFlag -> Bool) -> Eq DiffFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFlag -> DiffFlag -> Bool
$c/= :: DiffFlag -> DiffFlag -> Bool
== :: DiffFlag -> DiffFlag -> Bool
$c== :: DiffFlag -> DiffFlag -> Bool
Eq)
instance P.Enum DiffFlag where
fromEnum :: DiffFlag -> Int
fromEnum DiffFlagBinary = 1
fromEnum DiffFlagNotBinary = 2
fromEnum DiffFlagValidId = 4
fromEnum (AnotherDiffFlag k :: Int
k) = Int
k
toEnum :: Int -> DiffFlag
toEnum 1 = DiffFlag
DiffFlagBinary
toEnum 2 = DiffFlag
DiffFlagNotBinary
toEnum 4 = DiffFlag
DiffFlagValidId
toEnum k :: Int
k = Int -> DiffFlag
AnotherDiffFlag Int
k
instance P.Ord DiffFlag where
compare :: DiffFlag -> DiffFlag -> Ordering
compare a :: DiffFlag
a b :: 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
showList :: [DiffFindFlags] -> ShowS
$cshowList :: [DiffFindFlags] -> ShowS
show :: DiffFindFlags -> String
$cshow :: DiffFindFlags -> String
showsPrec :: Int -> DiffFindFlags -> ShowS
$cshowsPrec :: Int -> DiffFindFlags -> ShowS
Show, DiffFindFlags -> DiffFindFlags -> Bool
(DiffFindFlags -> DiffFindFlags -> Bool)
-> (DiffFindFlags -> DiffFindFlags -> Bool) -> Eq DiffFindFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFindFlags -> DiffFindFlags -> Bool
$c/= :: DiffFindFlags -> DiffFindFlags -> Bool
== :: DiffFindFlags -> DiffFindFlags -> Bool
$c== :: DiffFindFlags -> DiffFindFlags -> Bool
Eq)
instance P.Enum DiffFindFlags where
fromEnum :: DiffFindFlags -> Int
fromEnum DiffFindFlagsFindByConfig = 0
fromEnum DiffFindFlagsFindRenames = 1
fromEnum DiffFindFlagsFindRenamesFromRewrites = 2
fromEnum DiffFindFlagsFindCopies = 4
fromEnum DiffFindFlagsFindCopiesFromUnmodified = 8
fromEnum DiffFindFlagsFindRewrites = 16
fromEnum DiffFindFlagsBreakRewrites = 32
fromEnum DiffFindFlagsFindAndBreakRewrites = 48
fromEnum DiffFindFlagsFindForUntracked = 64
fromEnum DiffFindFlagsFindAll = 255
fromEnum DiffFindFlagsFindIgnoreLeadingWhitespace = 0
fromEnum DiffFindFlagsFindIgnoreWhitespace = 4096
fromEnum DiffFindFlagsFindDontIgnoreWhitespace = 8192
fromEnum DiffFindFlagsFindExactMatchOnly = 16384
fromEnum DiffFindFlagsBreakRewritesForRenamesOnly = 32768
fromEnum DiffFindFlagsFindRemoveUnmodified = 65536
fromEnum (AnotherDiffFindFlags k :: Int
k) = Int
k
toEnum :: Int -> DiffFindFlags
toEnum 0 = DiffFindFlags
DiffFindFlagsFindByConfig
toEnum 1 = DiffFindFlags
DiffFindFlagsFindRenames
toEnum 2 = DiffFindFlags
DiffFindFlagsFindRenamesFromRewrites
toEnum 4 = DiffFindFlags
DiffFindFlagsFindCopies
toEnum 8 = DiffFindFlags
DiffFindFlagsFindCopiesFromUnmodified
toEnum 16 = DiffFindFlags
DiffFindFlagsFindRewrites
toEnum 32 = DiffFindFlags
DiffFindFlagsBreakRewrites
toEnum 48 = DiffFindFlags
DiffFindFlagsFindAndBreakRewrites
toEnum 64 = DiffFindFlags
DiffFindFlagsFindForUntracked
toEnum 255 = DiffFindFlags
DiffFindFlagsFindAll
toEnum 4096 = DiffFindFlags
DiffFindFlagsFindIgnoreWhitespace
toEnum 8192 = DiffFindFlags
DiffFindFlagsFindDontIgnoreWhitespace
toEnum 16384 = DiffFindFlags
DiffFindFlagsFindExactMatchOnly
toEnum 32768 = DiffFindFlags
DiffFindFlagsBreakRewritesForRenamesOnly
toEnum 65536 = DiffFindFlags
DiffFindFlagsFindRemoveUnmodified
toEnum k :: Int
k = Int -> DiffFindFlags
AnotherDiffFindFlags Int
k
instance P.Ord DiffFindFlags where
compare :: DiffFindFlags -> DiffFindFlags -> Ordering
compare a :: DiffFindFlags
a b :: 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
showList :: [Credtype] -> ShowS
$cshowList :: [Credtype] -> ShowS
show :: Credtype -> String
$cshow :: Credtype -> String
showsPrec :: Int -> Credtype -> ShowS
$cshowsPrec :: Int -> Credtype -> ShowS
Show, Credtype -> Credtype -> Bool
(Credtype -> Credtype -> Bool)
-> (Credtype -> Credtype -> Bool) -> Eq Credtype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Credtype -> Credtype -> Bool
$c/= :: Credtype -> Credtype -> Bool
== :: Credtype -> Credtype -> Bool
$c== :: Credtype -> Credtype -> Bool
Eq)
instance P.Enum Credtype where
fromEnum :: Credtype -> Int
fromEnum CredtypeUserpassPlaintext = 1
fromEnum CredtypeSshKey = 2
fromEnum CredtypeSshCustom = 4
fromEnum CredtypeDefault = 8
fromEnum CredtypeSshInteractive = 16
fromEnum (AnotherCredtype k :: Int
k) = Int
k
toEnum :: Int -> Credtype
toEnum 1 = Credtype
CredtypeUserpassPlaintext
toEnum 2 = Credtype
CredtypeSshKey
toEnum 4 = Credtype
CredtypeSshCustom
toEnum 8 = Credtype
CredtypeDefault
toEnum 16 = Credtype
CredtypeSshInteractive
toEnum k :: Int
k = Int -> Credtype
AnotherCredtype Int
k
instance P.Ord Credtype where
compare :: Credtype -> Credtype -> Ordering
compare a :: Credtype
a b :: 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
showList :: [CreateFlags] -> ShowS
$cshowList :: [CreateFlags] -> ShowS
show :: CreateFlags -> String
$cshow :: CreateFlags -> String
showsPrec :: Int -> CreateFlags -> ShowS
$cshowsPrec :: Int -> CreateFlags -> ShowS
Show, CreateFlags -> CreateFlags -> Bool
(CreateFlags -> CreateFlags -> Bool)
-> (CreateFlags -> CreateFlags -> Bool) -> Eq CreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateFlags -> CreateFlags -> Bool
$c/= :: CreateFlags -> CreateFlags -> Bool
== :: CreateFlags -> CreateFlags -> Bool
$c== :: CreateFlags -> CreateFlags -> Bool
Eq)
instance P.Enum CreateFlags where
fromEnum :: CreateFlags -> Int
fromEnum CreateFlagsNone = 0
fromEnum CreateFlagsForce = 1
fromEnum (AnotherCreateFlags k :: Int
k) = Int
k
toEnum :: Int -> CreateFlags
toEnum 0 = CreateFlags
CreateFlagsNone
toEnum 1 = CreateFlags
CreateFlagsForce
toEnum k :: Int
k = Int -> CreateFlags
AnotherCreateFlags Int
k
instance P.Ord CreateFlags where
compare :: CreateFlags -> CreateFlags -> Ordering
compare a :: CreateFlags
a b :: 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
showList :: [CheckoutStrategy] -> ShowS
$cshowList :: [CheckoutStrategy] -> ShowS
show :: CheckoutStrategy -> String
$cshow :: CheckoutStrategy -> String
showsPrec :: Int -> CheckoutStrategy -> ShowS
$cshowsPrec :: Int -> CheckoutStrategy -> ShowS
Show, CheckoutStrategy -> CheckoutStrategy -> Bool
(CheckoutStrategy -> CheckoutStrategy -> Bool)
-> (CheckoutStrategy -> CheckoutStrategy -> Bool)
-> Eq CheckoutStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
$c/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
== :: CheckoutStrategy -> CheckoutStrategy -> Bool
$c== :: CheckoutStrategy -> CheckoutStrategy -> Bool
Eq)
instance P.Enum CheckoutStrategy where
fromEnum :: CheckoutStrategy -> Int
fromEnum CheckoutStrategyNone = 0
fromEnum CheckoutStrategySafe = 1
fromEnum CheckoutStrategyForce = 2
fromEnum CheckoutStrategyRecreateMissing = 4
fromEnum CheckoutStrategyAllowConflicts = 16
fromEnum CheckoutStrategyRemoveUntracked = 32
fromEnum CheckoutStrategyRemoveIgnored = 64
fromEnum CheckoutStrategyUpdateOnly = 128
fromEnum CheckoutStrategyDontUpdateIndex = 256
fromEnum CheckoutStrategyNoRefresh = 512
fromEnum CheckoutStrategySkipUnmerged = 1024
fromEnum CheckoutStrategyUseOurs = 2048
fromEnum CheckoutStrategyUseTheirs = 4096
fromEnum CheckoutStrategyDisablePathspecMatch = 8192
fromEnum CheckoutStrategySkipLockedDirectories = 262144
fromEnum CheckoutStrategyDontOverwriteIgnored = 524288
fromEnum CheckoutStrategyConflictStyleMerge = 1048576
fromEnum CheckoutStrategyConflictStyleDiff3 = 2097152
fromEnum CheckoutStrategyDontRemoveExisting = 4194304
fromEnum CheckoutStrategyDontWriteIndex = 8388608
fromEnum CheckoutStrategyUpdateSubmodules = 65536
fromEnum CheckoutStrategyUpdateSubmodulesIfChanged = 131072
fromEnum (AnotherCheckoutStrategy k :: Int
k) = Int
k
toEnum :: Int -> CheckoutStrategy
toEnum 0 = CheckoutStrategy
CheckoutStrategyNone
toEnum 1 = CheckoutStrategy
CheckoutStrategySafe
toEnum 2 = CheckoutStrategy
CheckoutStrategyForce
toEnum 4 = CheckoutStrategy
CheckoutStrategyRecreateMissing
toEnum 16 = CheckoutStrategy
CheckoutStrategyAllowConflicts
toEnum 32 = CheckoutStrategy
CheckoutStrategyRemoveUntracked
toEnum 64 = CheckoutStrategy
CheckoutStrategyRemoveIgnored
toEnum 128 = CheckoutStrategy
CheckoutStrategyUpdateOnly
toEnum 256 = CheckoutStrategy
CheckoutStrategyDontUpdateIndex
toEnum 512 = CheckoutStrategy
CheckoutStrategyNoRefresh
toEnum 1024 = CheckoutStrategy
CheckoutStrategySkipUnmerged
toEnum 2048 = CheckoutStrategy
CheckoutStrategyUseOurs
toEnum 4096 = CheckoutStrategy
CheckoutStrategyUseTheirs
toEnum 8192 = CheckoutStrategy
CheckoutStrategyDisablePathspecMatch
toEnum 262144 = CheckoutStrategy
CheckoutStrategySkipLockedDirectories
toEnum 524288 = CheckoutStrategy
CheckoutStrategyDontOverwriteIgnored
toEnum 1048576 = CheckoutStrategy
CheckoutStrategyConflictStyleMerge
toEnum 2097152 = CheckoutStrategy
CheckoutStrategyConflictStyleDiff3
toEnum 4194304 = CheckoutStrategy
CheckoutStrategyDontRemoveExisting
toEnum 8388608 = CheckoutStrategy
CheckoutStrategyDontWriteIndex
toEnum 65536 = CheckoutStrategy
CheckoutStrategyUpdateSubmodules
toEnum 131072 = CheckoutStrategy
CheckoutStrategyUpdateSubmodulesIfChanged
toEnum k :: Int
k = Int -> CheckoutStrategy
AnotherCheckoutStrategy Int
k
instance P.Ord CheckoutStrategy where
compare :: CheckoutStrategy -> CheckoutStrategy -> Ordering
compare a :: CheckoutStrategy
a b :: 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
showList :: [CheckoutNotifyFlags] -> ShowS
$cshowList :: [CheckoutNotifyFlags] -> ShowS
show :: CheckoutNotifyFlags -> String
$cshow :: CheckoutNotifyFlags -> String
showsPrec :: Int -> CheckoutNotifyFlags -> ShowS
$cshowsPrec :: Int -> CheckoutNotifyFlags -> ShowS
Show, CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
(CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> (CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> Eq CheckoutNotifyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
$c/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
$c== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
Eq)
instance P.Enum CheckoutNotifyFlags where
fromEnum :: CheckoutNotifyFlags -> Int
fromEnum CheckoutNotifyFlagsNone = 0
fromEnum CheckoutNotifyFlagsConflict = 1
fromEnum CheckoutNotifyFlagsDirty = 2
fromEnum CheckoutNotifyFlagsUpdated = 4
fromEnum CheckoutNotifyFlagsUntracked = 8
fromEnum CheckoutNotifyFlagsIgnored = 16
fromEnum CheckoutNotifyFlagsAll = 65535
fromEnum (AnotherCheckoutNotifyFlags k :: Int
k) = Int
k
toEnum :: Int -> CheckoutNotifyFlags
toEnum 0 = CheckoutNotifyFlags
CheckoutNotifyFlagsNone
toEnum 1 = CheckoutNotifyFlags
CheckoutNotifyFlagsConflict
toEnum 2 = CheckoutNotifyFlags
CheckoutNotifyFlagsDirty
toEnum 4 = CheckoutNotifyFlags
CheckoutNotifyFlagsUpdated
toEnum 8 = CheckoutNotifyFlags
CheckoutNotifyFlagsUntracked
toEnum 16 = CheckoutNotifyFlags
CheckoutNotifyFlagsIgnored
toEnum 65535 = CheckoutNotifyFlags
CheckoutNotifyFlagsAll
toEnum k :: Int
k = Int -> CheckoutNotifyFlags
AnotherCheckoutNotifyFlags Int
k
instance P.Ord CheckoutNotifyFlags where
compare :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Ordering
compare a :: CheckoutNotifyFlags
a b :: 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
showList :: [BlameFlags] -> ShowS
$cshowList :: [BlameFlags] -> ShowS
show :: BlameFlags -> String
$cshow :: BlameFlags -> String
showsPrec :: Int -> BlameFlags -> ShowS
$cshowsPrec :: Int -> BlameFlags -> ShowS
Show, BlameFlags -> BlameFlags -> Bool
(BlameFlags -> BlameFlags -> Bool)
-> (BlameFlags -> BlameFlags -> Bool) -> Eq BlameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlameFlags -> BlameFlags -> Bool
$c/= :: BlameFlags -> BlameFlags -> Bool
== :: BlameFlags -> BlameFlags -> Bool
$c== :: BlameFlags -> BlameFlags -> Bool
Eq)
instance P.Enum BlameFlags where
fromEnum :: BlameFlags -> Int
fromEnum BlameFlagsNormal = 0
fromEnum BlameFlagsTrackCopiesSameFile = 1
fromEnum (AnotherBlameFlags k :: Int
k) = Int
k
toEnum :: Int -> BlameFlags
toEnum 0 = BlameFlags
BlameFlagsNormal
toEnum 1 = BlameFlags
BlameFlagsTrackCopiesSameFile
toEnum k :: Int
k = Int -> BlameFlags
AnotherBlameFlags Int
k
instance P.Ord BlameFlags where
compare :: BlameFlags -> BlameFlags -> Ordering
compare a :: BlameFlags
a b :: 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
showList :: [AttributeCheckFlags] -> ShowS
$cshowList :: [AttributeCheckFlags] -> ShowS
show :: AttributeCheckFlags -> String
$cshow :: AttributeCheckFlags -> String
showsPrec :: Int -> AttributeCheckFlags -> ShowS
$cshowsPrec :: Int -> AttributeCheckFlags -> ShowS
Show, AttributeCheckFlags -> AttributeCheckFlags -> Bool
(AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> (AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> Eq AttributeCheckFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
$c/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
$c== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
Eq)
instance P.Enum AttributeCheckFlags where
fromEnum :: AttributeCheckFlags -> Int
fromEnum AttributeCheckFlagsFileThenIndex = 0
fromEnum AttributeCheckFlagsIndexThenFile = 1
fromEnum AttributeCheckFlagsIndexOnly = 2
fromEnum AttributeCheckFlagsNoSystem = 4
fromEnum (AnotherAttributeCheckFlags k :: Int
k) = Int
k
toEnum :: Int -> AttributeCheckFlags
toEnum 0 = AttributeCheckFlags
AttributeCheckFlagsFileThenIndex
toEnum 1 = AttributeCheckFlags
AttributeCheckFlagsIndexThenFile
toEnum 2 = AttributeCheckFlags
AttributeCheckFlagsIndexOnly
toEnum 4 = AttributeCheckFlags
AttributeCheckFlagsNoSystem
toEnum k :: Int
k = Int -> AttributeCheckFlags
AnotherAttributeCheckFlags Int
k
instance P.Ord AttributeCheckFlags where
compare :: AttributeCheckFlags -> AttributeCheckFlags -> Ordering
compare a :: AttributeCheckFlags
a b :: 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