#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified 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)
foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type ::
IO GType
instance BoxedFlags SubmoduleStatus where
boxedFlagsType :: Proxy SubmoduleStatus -> IO GType
boxedFlagsType _ = IO GType
c_ggit_submodule_status_get_type
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)
foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type ::
IO GType
instance BoxedFlags StatusOption where
boxedFlagsType :: Proxy StatusOption -> IO GType
boxedFlagsType _ = IO GType
c_ggit_status_option_get_type
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)
foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type ::
IO GType
instance BoxedFlags StatusFlags where
boxedFlagsType :: Proxy StatusFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_status_flags_get_type
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)
foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type ::
IO GType
instance BoxedFlags StashFlags where
boxedFlagsType :: Proxy StashFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_stash_flags_get_type
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)
foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type ::
IO GType
instance BoxedFlags SortMode where
boxedFlagsType :: Proxy SortMode -> IO GType
boxedFlagsType _ = IO GType
c_ggit_sort_mode_get_type
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)
foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type ::
IO GType
instance BoxedFlags MergeFlags where
boxedFlagsType :: Proxy MergeFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_merge_flags_get_type
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)
foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type ::
IO GType
instance BoxedFlags MergeFileFlags where
boxedFlagsType :: Proxy MergeFileFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_merge_file_flags_get_type
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)
foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type ::
IO GType
instance BoxedFlags FeatureFlags where
boxedFlagsType :: Proxy FeatureFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_feature_flags_get_type
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)
foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type ::
IO GType
instance BoxedFlags DiffOption where
boxedFlagsType :: Proxy DiffOption -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_option_get_type
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)
foreign import ccall "ggit_diff_format_email_flags_get_type" c_ggit_diff_format_email_flags_get_type ::
IO GType
instance BoxedFlags DiffFormatEmailFlags where
boxedFlagsType :: Proxy DiffFormatEmailFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_format_email_flags_get_type
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)
foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type ::
IO GType
instance BoxedFlags DiffFlag where
boxedFlagsType :: Proxy DiffFlag -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_flag_get_type
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)
foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type ::
IO GType
instance BoxedFlags DiffFindFlags where
boxedFlagsType :: Proxy DiffFindFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_find_flags_get_type
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)
foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type ::
IO GType
instance BoxedFlags Credtype where
boxedFlagsType :: Proxy Credtype -> IO GType
boxedFlagsType _ = IO GType
c_ggit_credtype_get_type
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)
foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type ::
IO GType
instance BoxedFlags CreateFlags where
boxedFlagsType :: Proxy CreateFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_create_flags_get_type
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)
foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type ::
IO GType
instance BoxedFlags CheckoutStrategy where
boxedFlagsType :: Proxy CheckoutStrategy -> IO GType
boxedFlagsType _ = IO GType
c_ggit_checkout_strategy_get_type
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)
foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type ::
IO GType
instance BoxedFlags CheckoutNotifyFlags where
boxedFlagsType :: Proxy CheckoutNotifyFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_checkout_notify_flags_get_type
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)
foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type ::
IO GType
instance BoxedFlags BlameFlags where
boxedFlagsType :: Proxy BlameFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_blame_flags_get_type
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)
foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type ::
IO GType
instance BoxedFlags AttributeCheckFlags where
boxedFlagsType :: Proxy AttributeCheckFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_attribute_check_flags_get_type
instance IsGFlag AttributeCheckFlags