#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Flags
(
ChecksumFlags(..) ,
DiffFlags(..) ,
GpgSignatureFormatFlags(..) ,
RepoCommitModifierFlags(..) ,
RepoCommitState(..) ,
RepoCommitTraverseFlags(..) ,
RepoListObjectsFlags(..) ,
RepoListRefsExtFlags(..) ,
RepoPruneFlags(..) ,
RepoPullFlags(..) ,
RepoResolveRevExtFlags(..) ,
RepoVerifyFlags(..) ,
SePolicyRestoreconFlags(..) ,
SysrootSimpleWriteDeploymentFlags(..) ,
SysrootUpgraderFlags(..) ,
SysrootUpgraderPullFlags(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data SysrootUpgraderPullFlags =
SysrootUpgraderPullFlagsNone
| SysrootUpgraderPullFlagsAllowOlder
| SysrootUpgraderPullFlagsSynthetic
| AnotherSysrootUpgraderPullFlags Int
deriving (Int -> SysrootUpgraderPullFlags -> ShowS
[SysrootUpgraderPullFlags] -> ShowS
SysrootUpgraderPullFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SysrootUpgraderPullFlags] -> ShowS
$cshowList :: [SysrootUpgraderPullFlags] -> ShowS
show :: SysrootUpgraderPullFlags -> String
$cshow :: SysrootUpgraderPullFlags -> String
showsPrec :: Int -> SysrootUpgraderPullFlags -> ShowS
$cshowsPrec :: Int -> SysrootUpgraderPullFlags -> ShowS
Show, SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool
$c/= :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool
== :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool
$c== :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool
Eq)
instance P.Enum SysrootUpgraderPullFlags where
fromEnum :: SysrootUpgraderPullFlags -> Int
fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsNone = Int
0
fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsAllowOlder = Int
1
fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsSynthetic = Int
2
fromEnum (AnotherSysrootUpgraderPullFlags Int
k) = Int
k
toEnum :: Int -> SysrootUpgraderPullFlags
toEnum Int
0 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsNone
toEnum Int
1 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsAllowOlder
toEnum Int
2 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsSynthetic
toEnum Int
k = Int -> SysrootUpgraderPullFlags
AnotherSysrootUpgraderPullFlags Int
k
instance P.Ord SysrootUpgraderPullFlags where
compare :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Ordering
compare SysrootUpgraderPullFlags
a SysrootUpgraderPullFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderPullFlags
a) (forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderPullFlags
b)
instance IsGFlag SysrootUpgraderPullFlags
data SysrootUpgraderFlags =
SysrootUpgraderFlagsIgnoreUnconfigured
| SysrootUpgraderFlagsStage
| AnotherSysrootUpgraderFlags Int
deriving (Int -> SysrootUpgraderFlags -> ShowS
[SysrootUpgraderFlags] -> ShowS
SysrootUpgraderFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SysrootUpgraderFlags] -> ShowS
$cshowList :: [SysrootUpgraderFlags] -> ShowS
show :: SysrootUpgraderFlags -> String
$cshow :: SysrootUpgraderFlags -> String
showsPrec :: Int -> SysrootUpgraderFlags -> ShowS
$cshowsPrec :: Int -> SysrootUpgraderFlags -> ShowS
Show, SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
$c/= :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
== :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
$c== :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
Eq)
instance P.Enum SysrootUpgraderFlags where
fromEnum :: SysrootUpgraderFlags -> Int
fromEnum SysrootUpgraderFlags
SysrootUpgraderFlagsIgnoreUnconfigured = Int
2
fromEnum SysrootUpgraderFlags
SysrootUpgraderFlagsStage = Int
4
fromEnum (AnotherSysrootUpgraderFlags Int
k) = Int
k
toEnum :: Int -> SysrootUpgraderFlags
toEnum Int
2 = SysrootUpgraderFlags
SysrootUpgraderFlagsIgnoreUnconfigured
toEnum Int
4 = SysrootUpgraderFlags
SysrootUpgraderFlagsStage
toEnum Int
k = Int -> SysrootUpgraderFlags
AnotherSysrootUpgraderFlags Int
k
instance P.Ord SysrootUpgraderFlags where
compare :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Ordering
compare SysrootUpgraderFlags
a SysrootUpgraderFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderFlags
a) (forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderFlags
b)
type instance O.ParentTypes SysrootUpgraderFlags = '[]
instance O.HasParentTypes SysrootUpgraderFlags
foreign import ccall "ostree_sysroot_upgrader_flags_get_type" c_ostree_sysroot_upgrader_flags_get_type ::
IO GType
instance B.Types.TypedObject SysrootUpgraderFlags where
glibType :: IO GType
glibType = IO GType
c_ostree_sysroot_upgrader_flags_get_type
instance B.Types.BoxedFlags SysrootUpgraderFlags
instance IsGFlag SysrootUpgraderFlags
data SysrootSimpleWriteDeploymentFlags =
SysrootSimpleWriteDeploymentFlagsNone
| SysrootSimpleWriteDeploymentFlagsRetain
| SysrootSimpleWriteDeploymentFlagsNotDefault
| SysrootSimpleWriteDeploymentFlagsNoClean
| SysrootSimpleWriteDeploymentFlagsRetainPending
| SysrootSimpleWriteDeploymentFlagsRetainRollback
| AnotherSysrootSimpleWriteDeploymentFlags Int
deriving (Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
[SysrootSimpleWriteDeploymentFlags] -> ShowS
SysrootSimpleWriteDeploymentFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SysrootSimpleWriteDeploymentFlags] -> ShowS
$cshowList :: [SysrootSimpleWriteDeploymentFlags] -> ShowS
show :: SysrootSimpleWriteDeploymentFlags -> String
$cshow :: SysrootSimpleWriteDeploymentFlags -> String
showsPrec :: Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
$cshowsPrec :: Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
Show, SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
$c/= :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
== :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
$c== :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
Eq)
instance P.Enum SysrootSimpleWriteDeploymentFlags where
fromEnum :: SysrootSimpleWriteDeploymentFlags -> Int
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNone = Int
0
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetain = Int
1
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNotDefault = Int
2
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNoClean = Int
4
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainPending = Int
8
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainRollback = Int
16
fromEnum (AnotherSysrootSimpleWriteDeploymentFlags Int
k) = Int
k
toEnum :: Int -> SysrootSimpleWriteDeploymentFlags
toEnum Int
0 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNone
toEnum Int
1 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetain
toEnum Int
2 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNotDefault
toEnum Int
4 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNoClean
toEnum Int
8 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainPending
toEnum Int
16 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainRollback
toEnum Int
k = Int -> SysrootSimpleWriteDeploymentFlags
AnotherSysrootSimpleWriteDeploymentFlags Int
k
instance P.Ord SysrootSimpleWriteDeploymentFlags where
compare :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Ordering
compare SysrootSimpleWriteDeploymentFlags
a SysrootSimpleWriteDeploymentFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum SysrootSimpleWriteDeploymentFlags
a) (forall a. Enum a => a -> Int
P.fromEnum SysrootSimpleWriteDeploymentFlags
b)
instance IsGFlag SysrootSimpleWriteDeploymentFlags
data SePolicyRestoreconFlags =
SePolicyRestoreconFlagsNone
| SePolicyRestoreconFlagsAllowNolabel
| SePolicyRestoreconFlagsKeepExisting
| AnotherSePolicyRestoreconFlags Int
deriving (Int -> SePolicyRestoreconFlags -> ShowS
[SePolicyRestoreconFlags] -> ShowS
SePolicyRestoreconFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SePolicyRestoreconFlags] -> ShowS
$cshowList :: [SePolicyRestoreconFlags] -> ShowS
show :: SePolicyRestoreconFlags -> String
$cshow :: SePolicyRestoreconFlags -> String
showsPrec :: Int -> SePolicyRestoreconFlags -> ShowS
$cshowsPrec :: Int -> SePolicyRestoreconFlags -> ShowS
Show, SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool
$c/= :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool
== :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool
$c== :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool
Eq)
instance P.Enum SePolicyRestoreconFlags where
fromEnum :: SePolicyRestoreconFlags -> Int
fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsNone = Int
0
fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsAllowNolabel = Int
1
fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsKeepExisting = Int
2
fromEnum (AnotherSePolicyRestoreconFlags Int
k) = Int
k
toEnum :: Int -> SePolicyRestoreconFlags
toEnum Int
0 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsNone
toEnum Int
1 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsAllowNolabel
toEnum Int
2 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsKeepExisting
toEnum Int
k = Int -> SePolicyRestoreconFlags
AnotherSePolicyRestoreconFlags Int
k
instance P.Ord SePolicyRestoreconFlags where
compare :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Ordering
compare SePolicyRestoreconFlags
a SePolicyRestoreconFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum SePolicyRestoreconFlags
a) (forall a. Enum a => a -> Int
P.fromEnum SePolicyRestoreconFlags
b)
instance IsGFlag SePolicyRestoreconFlags
data RepoVerifyFlags =
RepoVerifyFlagsNone
| RepoVerifyFlagsNoGpg
| RepoVerifyFlagsNoSignapi
| AnotherRepoVerifyFlags Int
deriving (Int -> RepoVerifyFlags -> ShowS
[RepoVerifyFlags] -> ShowS
RepoVerifyFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoVerifyFlags] -> ShowS
$cshowList :: [RepoVerifyFlags] -> ShowS
show :: RepoVerifyFlags -> String
$cshow :: RepoVerifyFlags -> String
showsPrec :: Int -> RepoVerifyFlags -> ShowS
$cshowsPrec :: Int -> RepoVerifyFlags -> ShowS
Show, RepoVerifyFlags -> RepoVerifyFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoVerifyFlags -> RepoVerifyFlags -> Bool
$c/= :: RepoVerifyFlags -> RepoVerifyFlags -> Bool
== :: RepoVerifyFlags -> RepoVerifyFlags -> Bool
$c== :: RepoVerifyFlags -> RepoVerifyFlags -> Bool
Eq)
instance P.Enum RepoVerifyFlags where
fromEnum :: RepoVerifyFlags -> Int
fromEnum RepoVerifyFlags
RepoVerifyFlagsNone = Int
0
fromEnum RepoVerifyFlags
RepoVerifyFlagsNoGpg = Int
1
fromEnum RepoVerifyFlags
RepoVerifyFlagsNoSignapi = Int
2
fromEnum (AnotherRepoVerifyFlags Int
k) = Int
k
toEnum :: Int -> RepoVerifyFlags
toEnum Int
0 = RepoVerifyFlags
RepoVerifyFlagsNone
toEnum Int
1 = RepoVerifyFlags
RepoVerifyFlagsNoGpg
toEnum Int
2 = RepoVerifyFlags
RepoVerifyFlagsNoSignapi
toEnum Int
k = Int -> RepoVerifyFlags
AnotherRepoVerifyFlags Int
k
instance P.Ord RepoVerifyFlags where
compare :: RepoVerifyFlags -> RepoVerifyFlags -> Ordering
compare RepoVerifyFlags
a RepoVerifyFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoVerifyFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoVerifyFlags
b)
instance IsGFlag RepoVerifyFlags
data RepoResolveRevExtFlags =
RepoResolveRevExtFlagsNone
| RepoResolveRevExtFlagsLocalOnly
| AnotherRepoResolveRevExtFlags Int
deriving (Int -> RepoResolveRevExtFlags -> ShowS
[RepoResolveRevExtFlags] -> ShowS
RepoResolveRevExtFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoResolveRevExtFlags] -> ShowS
$cshowList :: [RepoResolveRevExtFlags] -> ShowS
show :: RepoResolveRevExtFlags -> String
$cshow :: RepoResolveRevExtFlags -> String
showsPrec :: Int -> RepoResolveRevExtFlags -> ShowS
$cshowsPrec :: Int -> RepoResolveRevExtFlags -> ShowS
Show, RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
$c/= :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
== :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
$c== :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
Eq)
instance P.Enum RepoResolveRevExtFlags where
fromEnum :: RepoResolveRevExtFlags -> Int
fromEnum RepoResolveRevExtFlags
RepoResolveRevExtFlagsNone = Int
0
fromEnum RepoResolveRevExtFlags
RepoResolveRevExtFlagsLocalOnly = Int
1
fromEnum (AnotherRepoResolveRevExtFlags Int
k) = Int
k
toEnum :: Int -> RepoResolveRevExtFlags
toEnum Int
0 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsNone
toEnum Int
1 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsLocalOnly
toEnum Int
k = Int -> RepoResolveRevExtFlags
AnotherRepoResolveRevExtFlags Int
k
instance P.Ord RepoResolveRevExtFlags where
compare :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Ordering
compare RepoResolveRevExtFlags
a RepoResolveRevExtFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoResolveRevExtFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoResolveRevExtFlags
b)
instance IsGFlag RepoResolveRevExtFlags
data RepoPullFlags =
RepoPullFlagsNone
| RepoPullFlagsMirror
| RepoPullFlagsCommitOnly
| RepoPullFlagsUntrusted
| RepoPullFlagsBareuseronlyFiles
| RepoPullFlagsTrustedHttp
| AnotherRepoPullFlags Int
deriving (Int -> RepoPullFlags -> ShowS
[RepoPullFlags] -> ShowS
RepoPullFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoPullFlags] -> ShowS
$cshowList :: [RepoPullFlags] -> ShowS
show :: RepoPullFlags -> String
$cshow :: RepoPullFlags -> String
showsPrec :: Int -> RepoPullFlags -> ShowS
$cshowsPrec :: Int -> RepoPullFlags -> ShowS
Show, RepoPullFlags -> RepoPullFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPullFlags -> RepoPullFlags -> Bool
$c/= :: RepoPullFlags -> RepoPullFlags -> Bool
== :: RepoPullFlags -> RepoPullFlags -> Bool
$c== :: RepoPullFlags -> RepoPullFlags -> Bool
Eq)
instance P.Enum RepoPullFlags where
fromEnum :: RepoPullFlags -> Int
fromEnum RepoPullFlags
RepoPullFlagsNone = Int
0
fromEnum RepoPullFlags
RepoPullFlagsMirror = Int
1
fromEnum RepoPullFlags
RepoPullFlagsCommitOnly = Int
2
fromEnum RepoPullFlags
RepoPullFlagsUntrusted = Int
4
fromEnum RepoPullFlags
RepoPullFlagsBareuseronlyFiles = Int
8
fromEnum RepoPullFlags
RepoPullFlagsTrustedHttp = Int
16
fromEnum (AnotherRepoPullFlags Int
k) = Int
k
toEnum :: Int -> RepoPullFlags
toEnum Int
0 = RepoPullFlags
RepoPullFlagsNone
toEnum Int
1 = RepoPullFlags
RepoPullFlagsMirror
toEnum Int
2 = RepoPullFlags
RepoPullFlagsCommitOnly
toEnum Int
4 = RepoPullFlags
RepoPullFlagsUntrusted
toEnum Int
8 = RepoPullFlags
RepoPullFlagsBareuseronlyFiles
toEnum Int
16 = RepoPullFlags
RepoPullFlagsTrustedHttp
toEnum Int
k = Int -> RepoPullFlags
AnotherRepoPullFlags Int
k
instance P.Ord RepoPullFlags where
compare :: RepoPullFlags -> RepoPullFlags -> Ordering
compare RepoPullFlags
a RepoPullFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoPullFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoPullFlags
b)
instance IsGFlag RepoPullFlags
data RepoPruneFlags =
RepoPruneFlagsNone
| RepoPruneFlagsNoPrune
| RepoPruneFlagsRefsOnly
| RepoPruneFlagsCommitOnly
| AnotherRepoPruneFlags Int
deriving (Int -> RepoPruneFlags -> ShowS
[RepoPruneFlags] -> ShowS
RepoPruneFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoPruneFlags] -> ShowS
$cshowList :: [RepoPruneFlags] -> ShowS
show :: RepoPruneFlags -> String
$cshow :: RepoPruneFlags -> String
showsPrec :: Int -> RepoPruneFlags -> ShowS
$cshowsPrec :: Int -> RepoPruneFlags -> ShowS
Show, RepoPruneFlags -> RepoPruneFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPruneFlags -> RepoPruneFlags -> Bool
$c/= :: RepoPruneFlags -> RepoPruneFlags -> Bool
== :: RepoPruneFlags -> RepoPruneFlags -> Bool
$c== :: RepoPruneFlags -> RepoPruneFlags -> Bool
Eq)
instance P.Enum RepoPruneFlags where
fromEnum :: RepoPruneFlags -> Int
fromEnum RepoPruneFlags
RepoPruneFlagsNone = Int
0
fromEnum RepoPruneFlags
RepoPruneFlagsNoPrune = Int
1
fromEnum RepoPruneFlags
RepoPruneFlagsRefsOnly = Int
2
fromEnum RepoPruneFlags
RepoPruneFlagsCommitOnly = Int
4
fromEnum (AnotherRepoPruneFlags Int
k) = Int
k
toEnum :: Int -> RepoPruneFlags
toEnum Int
0 = RepoPruneFlags
RepoPruneFlagsNone
toEnum Int
1 = RepoPruneFlags
RepoPruneFlagsNoPrune
toEnum Int
2 = RepoPruneFlags
RepoPruneFlagsRefsOnly
toEnum Int
4 = RepoPruneFlags
RepoPruneFlagsCommitOnly
toEnum Int
k = Int -> RepoPruneFlags
AnotherRepoPruneFlags Int
k
instance P.Ord RepoPruneFlags where
compare :: RepoPruneFlags -> RepoPruneFlags -> Ordering
compare RepoPruneFlags
a RepoPruneFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoPruneFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoPruneFlags
b)
instance IsGFlag RepoPruneFlags
data RepoListRefsExtFlags =
RepoListRefsExtFlagsNone
| RepoListRefsExtFlagsAliases
| RepoListRefsExtFlagsExcludeRemotes
| RepoListRefsExtFlagsExcludeMirrors
| AnotherRepoListRefsExtFlags Int
deriving (Int -> RepoListRefsExtFlags -> ShowS
[RepoListRefsExtFlags] -> ShowS
RepoListRefsExtFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoListRefsExtFlags] -> ShowS
$cshowList :: [RepoListRefsExtFlags] -> ShowS
show :: RepoListRefsExtFlags -> String
$cshow :: RepoListRefsExtFlags -> String
showsPrec :: Int -> RepoListRefsExtFlags -> ShowS
$cshowsPrec :: Int -> RepoListRefsExtFlags -> ShowS
Show, RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
$c/= :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
== :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
$c== :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
Eq)
instance P.Enum RepoListRefsExtFlags where
fromEnum :: RepoListRefsExtFlags -> Int
fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsNone = Int
0
fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsAliases = Int
1
fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeRemotes = Int
2
fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeMirrors = Int
4
fromEnum (AnotherRepoListRefsExtFlags Int
k) = Int
k
toEnum :: Int -> RepoListRefsExtFlags
toEnum Int
0 = RepoListRefsExtFlags
RepoListRefsExtFlagsNone
toEnum Int
1 = RepoListRefsExtFlags
RepoListRefsExtFlagsAliases
toEnum Int
2 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeRemotes
toEnum Int
4 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeMirrors
toEnum Int
k = Int -> RepoListRefsExtFlags
AnotherRepoListRefsExtFlags Int
k
instance P.Ord RepoListRefsExtFlags where
compare :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Ordering
compare RepoListRefsExtFlags
a RepoListRefsExtFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoListRefsExtFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoListRefsExtFlags
b)
instance IsGFlag RepoListRefsExtFlags
data RepoListObjectsFlags =
RepoListObjectsFlagsLoose
| RepoListObjectsFlagsPacked
| RepoListObjectsFlagsAll
| RepoListObjectsFlagsNoParents
| AnotherRepoListObjectsFlags Int
deriving (Int -> RepoListObjectsFlags -> ShowS
[RepoListObjectsFlags] -> ShowS
RepoListObjectsFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoListObjectsFlags] -> ShowS
$cshowList :: [RepoListObjectsFlags] -> ShowS
show :: RepoListObjectsFlags -> String
$cshow :: RepoListObjectsFlags -> String
showsPrec :: Int -> RepoListObjectsFlags -> ShowS
$cshowsPrec :: Int -> RepoListObjectsFlags -> ShowS
Show, RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
$c/= :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
== :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
$c== :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
Eq)
instance P.Enum RepoListObjectsFlags where
fromEnum :: RepoListObjectsFlags -> Int
fromEnum RepoListObjectsFlags
RepoListObjectsFlagsLoose = Int
1
fromEnum RepoListObjectsFlags
RepoListObjectsFlagsPacked = Int
2
fromEnum RepoListObjectsFlags
RepoListObjectsFlagsAll = Int
4
fromEnum RepoListObjectsFlags
RepoListObjectsFlagsNoParents = Int
8
fromEnum (AnotherRepoListObjectsFlags Int
k) = Int
k
toEnum :: Int -> RepoListObjectsFlags
toEnum Int
1 = RepoListObjectsFlags
RepoListObjectsFlagsLoose
toEnum Int
2 = RepoListObjectsFlags
RepoListObjectsFlagsPacked
toEnum Int
4 = RepoListObjectsFlags
RepoListObjectsFlagsAll
toEnum Int
8 = RepoListObjectsFlags
RepoListObjectsFlagsNoParents
toEnum Int
k = Int -> RepoListObjectsFlags
AnotherRepoListObjectsFlags Int
k
instance P.Ord RepoListObjectsFlags where
compare :: RepoListObjectsFlags -> RepoListObjectsFlags -> Ordering
compare RepoListObjectsFlags
a RepoListObjectsFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoListObjectsFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoListObjectsFlags
b)
instance IsGFlag RepoListObjectsFlags
data RepoCommitTraverseFlags =
RepoCommitTraverseFlagsNone
| RepoCommitTraverseFlagsCommitOnly
| AnotherRepoCommitTraverseFlags Int
deriving (Int -> RepoCommitTraverseFlags -> ShowS
[RepoCommitTraverseFlags] -> ShowS
RepoCommitTraverseFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoCommitTraverseFlags] -> ShowS
$cshowList :: [RepoCommitTraverseFlags] -> ShowS
show :: RepoCommitTraverseFlags -> String
$cshow :: RepoCommitTraverseFlags -> String
showsPrec :: Int -> RepoCommitTraverseFlags -> ShowS
$cshowsPrec :: Int -> RepoCommitTraverseFlags -> ShowS
Show, RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool
$c/= :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool
== :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool
$c== :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool
Eq)
instance P.Enum RepoCommitTraverseFlags where
fromEnum :: RepoCommitTraverseFlags -> Int
fromEnum RepoCommitTraverseFlags
RepoCommitTraverseFlagsNone = Int
1
fromEnum RepoCommitTraverseFlags
RepoCommitTraverseFlagsCommitOnly = Int
2
fromEnum (AnotherRepoCommitTraverseFlags Int
k) = Int
k
toEnum :: Int -> RepoCommitTraverseFlags
toEnum Int
1 = RepoCommitTraverseFlags
RepoCommitTraverseFlagsNone
toEnum Int
2 = RepoCommitTraverseFlags
RepoCommitTraverseFlagsCommitOnly
toEnum Int
k = Int -> RepoCommitTraverseFlags
AnotherRepoCommitTraverseFlags Int
k
instance P.Ord RepoCommitTraverseFlags where
compare :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Ordering
compare RepoCommitTraverseFlags
a RepoCommitTraverseFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoCommitTraverseFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoCommitTraverseFlags
b)
instance IsGFlag RepoCommitTraverseFlags
data RepoCommitState =
RepoCommitStateNormal
| RepoCommitStatePartial
| RepoCommitStateFsckPartial
| AnotherRepoCommitState Int
deriving (Int -> RepoCommitState -> ShowS
[RepoCommitState] -> ShowS
RepoCommitState -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoCommitState] -> ShowS
$cshowList :: [RepoCommitState] -> ShowS
show :: RepoCommitState -> String
$cshow :: RepoCommitState -> String
showsPrec :: Int -> RepoCommitState -> ShowS
$cshowsPrec :: Int -> RepoCommitState -> ShowS
Show, RepoCommitState -> RepoCommitState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitState -> RepoCommitState -> Bool
$c/= :: RepoCommitState -> RepoCommitState -> Bool
== :: RepoCommitState -> RepoCommitState -> Bool
$c== :: RepoCommitState -> RepoCommitState -> Bool
Eq)
instance P.Enum RepoCommitState where
fromEnum :: RepoCommitState -> Int
fromEnum RepoCommitState
RepoCommitStateNormal = Int
0
fromEnum RepoCommitState
RepoCommitStatePartial = Int
1
fromEnum RepoCommitState
RepoCommitStateFsckPartial = Int
2
fromEnum (AnotherRepoCommitState Int
k) = Int
k
toEnum :: Int -> RepoCommitState
toEnum Int
0 = RepoCommitState
RepoCommitStateNormal
toEnum Int
1 = RepoCommitState
RepoCommitStatePartial
toEnum Int
2 = RepoCommitState
RepoCommitStateFsckPartial
toEnum Int
k = Int -> RepoCommitState
AnotherRepoCommitState Int
k
instance P.Ord RepoCommitState where
compare :: RepoCommitState -> RepoCommitState -> Ordering
compare RepoCommitState
a RepoCommitState
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoCommitState
a) (forall a. Enum a => a -> Int
P.fromEnum RepoCommitState
b)
instance IsGFlag RepoCommitState
data RepoCommitModifierFlags =
RepoCommitModifierFlagsNone
| RepoCommitModifierFlagsSkipXattrs
| RepoCommitModifierFlagsGenerateSizes
| RepoCommitModifierFlagsCanonicalPermissions
| RepoCommitModifierFlagsErrorOnUnlabeled
| RepoCommitModifierFlagsConsume
| RepoCommitModifierFlagsDevinoCanonical
| AnotherRepoCommitModifierFlags Int
deriving (Int -> RepoCommitModifierFlags -> ShowS
[RepoCommitModifierFlags] -> ShowS
RepoCommitModifierFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoCommitModifierFlags] -> ShowS
$cshowList :: [RepoCommitModifierFlags] -> ShowS
show :: RepoCommitModifierFlags -> String
$cshow :: RepoCommitModifierFlags -> String
showsPrec :: Int -> RepoCommitModifierFlags -> ShowS
$cshowsPrec :: Int -> RepoCommitModifierFlags -> ShowS
Show, RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
$c/= :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
== :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
$c== :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
Eq)
instance P.Enum RepoCommitModifierFlags where
fromEnum :: RepoCommitModifierFlags -> Int
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsNone = Int
0
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsSkipXattrs = Int
1
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsGenerateSizes = Int
2
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsCanonicalPermissions = Int
4
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsErrorOnUnlabeled = Int
8
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsConsume = Int
16
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsDevinoCanonical = Int
32
fromEnum (AnotherRepoCommitModifierFlags Int
k) = Int
k
toEnum :: Int -> RepoCommitModifierFlags
toEnum Int
0 = RepoCommitModifierFlags
RepoCommitModifierFlagsNone
toEnum Int
1 = RepoCommitModifierFlags
RepoCommitModifierFlagsSkipXattrs
toEnum Int
2 = RepoCommitModifierFlags
RepoCommitModifierFlagsGenerateSizes
toEnum Int
4 = RepoCommitModifierFlags
RepoCommitModifierFlagsCanonicalPermissions
toEnum Int
8 = RepoCommitModifierFlags
RepoCommitModifierFlagsErrorOnUnlabeled
toEnum Int
16 = RepoCommitModifierFlags
RepoCommitModifierFlagsConsume
toEnum Int
32 = RepoCommitModifierFlags
RepoCommitModifierFlagsDevinoCanonical
toEnum Int
k = Int -> RepoCommitModifierFlags
AnotherRepoCommitModifierFlags Int
k
instance P.Ord RepoCommitModifierFlags where
compare :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Ordering
compare RepoCommitModifierFlags
a RepoCommitModifierFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum RepoCommitModifierFlags
a) (forall a. Enum a => a -> Int
P.fromEnum RepoCommitModifierFlags
b)
instance IsGFlag RepoCommitModifierFlags
data GpgSignatureFormatFlags =
GpgSignatureFormatFlagsGpgSignatureFormatDefault
| AnotherGpgSignatureFormatFlags Int
deriving (Int -> GpgSignatureFormatFlags -> ShowS
[GpgSignatureFormatFlags] -> ShowS
GpgSignatureFormatFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GpgSignatureFormatFlags] -> ShowS
$cshowList :: [GpgSignatureFormatFlags] -> ShowS
show :: GpgSignatureFormatFlags -> String
$cshow :: GpgSignatureFormatFlags -> String
showsPrec :: Int -> GpgSignatureFormatFlags -> ShowS
$cshowsPrec :: Int -> GpgSignatureFormatFlags -> ShowS
Show, GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
$c/= :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
== :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
$c== :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
Eq)
instance P.Enum GpgSignatureFormatFlags where
fromEnum :: GpgSignatureFormatFlags -> Int
fromEnum GpgSignatureFormatFlags
GpgSignatureFormatFlagsGpgSignatureFormatDefault = Int
0
fromEnum (AnotherGpgSignatureFormatFlags Int
k) = Int
k
toEnum :: Int -> GpgSignatureFormatFlags
toEnum Int
0 = GpgSignatureFormatFlags
GpgSignatureFormatFlagsGpgSignatureFormatDefault
toEnum Int
k = Int -> GpgSignatureFormatFlags
AnotherGpgSignatureFormatFlags Int
k
instance P.Ord GpgSignatureFormatFlags where
compare :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Ordering
compare GpgSignatureFormatFlags
a GpgSignatureFormatFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum GpgSignatureFormatFlags
a) (forall a. Enum a => a -> Int
P.fromEnum GpgSignatureFormatFlags
b)
instance IsGFlag GpgSignatureFormatFlags
data DiffFlags =
DiffFlagsNone
| DiffFlagsIgnoreXattrs
| AnotherDiffFlags Int
deriving (Int -> DiffFlags -> ShowS
[DiffFlags] -> ShowS
DiffFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DiffFlags] -> ShowS
$cshowList :: [DiffFlags] -> ShowS
show :: DiffFlags -> String
$cshow :: DiffFlags -> String
showsPrec :: Int -> DiffFlags -> ShowS
$cshowsPrec :: Int -> DiffFlags -> ShowS
Show, DiffFlags -> DiffFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFlags -> DiffFlags -> Bool
$c/= :: DiffFlags -> DiffFlags -> Bool
== :: DiffFlags -> DiffFlags -> Bool
$c== :: DiffFlags -> DiffFlags -> Bool
Eq)
instance P.Enum DiffFlags where
fromEnum :: DiffFlags -> Int
fromEnum DiffFlags
DiffFlagsNone = Int
0
fromEnum DiffFlags
DiffFlagsIgnoreXattrs = Int
1
fromEnum (AnotherDiffFlags Int
k) = Int
k
toEnum :: Int -> DiffFlags
toEnum Int
0 = DiffFlags
DiffFlagsNone
toEnum Int
1 = DiffFlags
DiffFlagsIgnoreXattrs
toEnum Int
k = Int -> DiffFlags
AnotherDiffFlags Int
k
instance P.Ord DiffFlags where
compare :: DiffFlags -> DiffFlags -> Ordering
compare DiffFlags
a DiffFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum DiffFlags
a) (forall a. Enum a => a -> Int
P.fromEnum DiffFlags
b)
instance IsGFlag DiffFlags
data ChecksumFlags =
ChecksumFlagsNone
| ChecksumFlagsIgnoreXattrs
| ChecksumFlagsCanonicalPermissions
| AnotherChecksumFlags Int
deriving (Int -> ChecksumFlags -> ShowS
[ChecksumFlags] -> ShowS
ChecksumFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChecksumFlags] -> ShowS
$cshowList :: [ChecksumFlags] -> ShowS
show :: ChecksumFlags -> String
$cshow :: ChecksumFlags -> String
showsPrec :: Int -> ChecksumFlags -> ShowS
$cshowsPrec :: Int -> ChecksumFlags -> ShowS
Show, ChecksumFlags -> ChecksumFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChecksumFlags -> ChecksumFlags -> Bool
$c/= :: ChecksumFlags -> ChecksumFlags -> Bool
== :: ChecksumFlags -> ChecksumFlags -> Bool
$c== :: ChecksumFlags -> ChecksumFlags -> Bool
Eq)
instance P.Enum ChecksumFlags where
fromEnum :: ChecksumFlags -> Int
fromEnum ChecksumFlags
ChecksumFlagsNone = Int
0
fromEnum ChecksumFlags
ChecksumFlagsIgnoreXattrs = Int
1
fromEnum ChecksumFlags
ChecksumFlagsCanonicalPermissions = Int
2
fromEnum (AnotherChecksumFlags Int
k) = Int
k
toEnum :: Int -> ChecksumFlags
toEnum Int
0 = ChecksumFlags
ChecksumFlagsNone
toEnum Int
1 = ChecksumFlags
ChecksumFlagsIgnoreXattrs
toEnum Int
2 = ChecksumFlags
ChecksumFlagsCanonicalPermissions
toEnum Int
k = Int -> ChecksumFlags
AnotherChecksumFlags Int
k
instance P.Ord ChecksumFlags where
compare :: ChecksumFlags -> ChecksumFlags -> Ordering
compare ChecksumFlags
a ChecksumFlags
b = forall a. Ord a => a -> a -> Ordering
P.compare (forall a. Enum a => a -> Int
P.fromEnum ChecksumFlags
a) (forall a. Enum a => a -> Int
P.fromEnum ChecksumFlags
b)
instance IsGFlag ChecksumFlags