#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.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
(Int -> SysrootUpgraderPullFlags -> ShowS)
-> (SysrootUpgraderPullFlags -> String)
-> ([SysrootUpgraderPullFlags] -> ShowS)
-> Show SysrootUpgraderPullFlags
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
(SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool)
-> (SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Bool)
-> Eq SysrootUpgraderPullFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SysrootUpgraderPullFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderPullFlags
a) (SysrootUpgraderPullFlags -> Int
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
(Int -> SysrootUpgraderFlags -> ShowS)
-> (SysrootUpgraderFlags -> String)
-> ([SysrootUpgraderFlags] -> ShowS)
-> Show SysrootUpgraderFlags
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
(SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool)
-> (SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool)
-> Eq SysrootUpgraderFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SysrootUpgraderFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SysrootUpgraderFlags
a) (SysrootUpgraderFlags -> Int
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
(Int -> SysrootSimpleWriteDeploymentFlags -> ShowS)
-> (SysrootSimpleWriteDeploymentFlags -> String)
-> ([SysrootSimpleWriteDeploymentFlags] -> ShowS)
-> Show SysrootSimpleWriteDeploymentFlags
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
(SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool)
-> (SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool)
-> Eq SysrootSimpleWriteDeploymentFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SysrootSimpleWriteDeploymentFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SysrootSimpleWriteDeploymentFlags
a) (SysrootSimpleWriteDeploymentFlags -> Int
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
(Int -> SePolicyRestoreconFlags -> ShowS)
-> (SePolicyRestoreconFlags -> String)
-> ([SePolicyRestoreconFlags] -> ShowS)
-> Show SePolicyRestoreconFlags
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
(SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool)
-> (SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Bool)
-> Eq SePolicyRestoreconFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SePolicyRestoreconFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SePolicyRestoreconFlags
a) (SePolicyRestoreconFlags -> Int
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
(Int -> RepoVerifyFlags -> ShowS)
-> (RepoVerifyFlags -> String)
-> ([RepoVerifyFlags] -> ShowS)
-> Show RepoVerifyFlags
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
(RepoVerifyFlags -> RepoVerifyFlags -> Bool)
-> (RepoVerifyFlags -> RepoVerifyFlags -> Bool)
-> Eq RepoVerifyFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoVerifyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoVerifyFlags
a) (RepoVerifyFlags -> Int
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
(Int -> RepoResolveRevExtFlags -> ShowS)
-> (RepoResolveRevExtFlags -> String)
-> ([RepoResolveRevExtFlags] -> ShowS)
-> Show RepoResolveRevExtFlags
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
(RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool)
-> (RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool)
-> Eq RepoResolveRevExtFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoResolveRevExtFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoResolveRevExtFlags
a) (RepoResolveRevExtFlags -> Int
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
(Int -> RepoPullFlags -> ShowS)
-> (RepoPullFlags -> String)
-> ([RepoPullFlags] -> ShowS)
-> Show RepoPullFlags
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
(RepoPullFlags -> RepoPullFlags -> Bool)
-> (RepoPullFlags -> RepoPullFlags -> Bool) -> Eq RepoPullFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoPullFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoPullFlags
a) (RepoPullFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoPullFlags
b)
instance IsGFlag RepoPullFlags
data RepoPruneFlags =
RepoPruneFlagsNone
| RepoPruneFlagsNoPrune
| RepoPruneFlagsRefsOnly
| AnotherRepoPruneFlags Int
deriving (Int -> RepoPruneFlags -> ShowS
[RepoPruneFlags] -> ShowS
RepoPruneFlags -> String
(Int -> RepoPruneFlags -> ShowS)
-> (RepoPruneFlags -> String)
-> ([RepoPruneFlags] -> ShowS)
-> Show RepoPruneFlags
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
(RepoPruneFlags -> RepoPruneFlags -> Bool)
-> (RepoPruneFlags -> RepoPruneFlags -> Bool) -> Eq RepoPruneFlags
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 (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
k = Int -> RepoPruneFlags
AnotherRepoPruneFlags Int
k
instance P.Ord RepoPruneFlags where
compare :: RepoPruneFlags -> RepoPruneFlags -> Ordering
compare RepoPruneFlags
a RepoPruneFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoPruneFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoPruneFlags
a) (RepoPruneFlags -> Int
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
(Int -> RepoListRefsExtFlags -> ShowS)
-> (RepoListRefsExtFlags -> String)
-> ([RepoListRefsExtFlags] -> ShowS)
-> Show RepoListRefsExtFlags
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
(RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool)
-> (RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool)
-> Eq RepoListRefsExtFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoListRefsExtFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoListRefsExtFlags
a) (RepoListRefsExtFlags -> Int
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
(Int -> RepoListObjectsFlags -> ShowS)
-> (RepoListObjectsFlags -> String)
-> ([RepoListObjectsFlags] -> ShowS)
-> Show RepoListObjectsFlags
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
(RepoListObjectsFlags -> RepoListObjectsFlags -> Bool)
-> (RepoListObjectsFlags -> RepoListObjectsFlags -> Bool)
-> Eq RepoListObjectsFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoListObjectsFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoListObjectsFlags
a) (RepoListObjectsFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoListObjectsFlags
b)
instance IsGFlag RepoListObjectsFlags
data RepoCommitTraverseFlags =
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone
| AnotherRepoCommitTraverseFlags Int
deriving (Int -> RepoCommitTraverseFlags -> ShowS
[RepoCommitTraverseFlags] -> ShowS
RepoCommitTraverseFlags -> String
(Int -> RepoCommitTraverseFlags -> ShowS)
-> (RepoCommitTraverseFlags -> String)
-> ([RepoCommitTraverseFlags] -> ShowS)
-> Show RepoCommitTraverseFlags
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
(RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool)
-> (RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Bool)
-> Eq RepoCommitTraverseFlags
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
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone = Int
1
fromEnum (AnotherRepoCommitTraverseFlags Int
k) = Int
k
toEnum :: Int -> RepoCommitTraverseFlags
toEnum Int
1 = RepoCommitTraverseFlags
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone
toEnum Int
k = Int -> RepoCommitTraverseFlags
AnotherRepoCommitTraverseFlags Int
k
instance P.Ord RepoCommitTraverseFlags where
compare :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Ordering
compare RepoCommitTraverseFlags
a RepoCommitTraverseFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoCommitTraverseFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoCommitTraverseFlags
a) (RepoCommitTraverseFlags -> Int
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
(Int -> RepoCommitState -> ShowS)
-> (RepoCommitState -> String)
-> ([RepoCommitState] -> ShowS)
-> Show RepoCommitState
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
(RepoCommitState -> RepoCommitState -> Bool)
-> (RepoCommitState -> RepoCommitState -> Bool)
-> Eq RepoCommitState
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoCommitState -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoCommitState
a) (RepoCommitState -> Int
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
(Int -> RepoCommitModifierFlags -> ShowS)
-> (RepoCommitModifierFlags -> String)
-> ([RepoCommitModifierFlags] -> ShowS)
-> Show RepoCommitModifierFlags
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
(RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool)
-> (RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool)
-> Eq RepoCommitModifierFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RepoCommitModifierFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum RepoCommitModifierFlags
a) (RepoCommitModifierFlags -> Int
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
(Int -> GpgSignatureFormatFlags -> ShowS)
-> (GpgSignatureFormatFlags -> String)
-> ([GpgSignatureFormatFlags] -> ShowS)
-> Show GpgSignatureFormatFlags
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
(GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool)
-> (GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool)
-> Eq GpgSignatureFormatFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GpgSignatureFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum GpgSignatureFormatFlags
a) (GpgSignatureFormatFlags -> Int
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
(Int -> DiffFlags -> ShowS)
-> (DiffFlags -> String)
-> ([DiffFlags] -> ShowS)
-> Show DiffFlags
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
(DiffFlags -> DiffFlags -> Bool)
-> (DiffFlags -> DiffFlags -> Bool) -> Eq DiffFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFlags
a) (DiffFlags -> Int
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
(Int -> ChecksumFlags -> ShowS)
-> (ChecksumFlags -> String)
-> ([ChecksumFlags] -> ShowS)
-> Show ChecksumFlags
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
(ChecksumFlags -> ChecksumFlags -> Bool)
-> (ChecksumFlags -> ChecksumFlags -> Bool) -> Eq ChecksumFlags
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 = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ChecksumFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ChecksumFlags
a) (ChecksumFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ChecksumFlags
b)
instance IsGFlag ChecksumFlags