#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(..) ,
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.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 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 SysrootUpgraderPullFlagsNone = 0
fromEnum SysrootUpgraderPullFlagsAllowOlder = 1
fromEnum SysrootUpgraderPullFlagsSynthetic = 2
fromEnum (AnotherSysrootUpgraderPullFlags k :: Int
k) = Int
k
toEnum :: Int -> SysrootUpgraderPullFlags
toEnum 0 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsNone
toEnum 1 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsAllowOlder
toEnum 2 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsSynthetic
toEnum k :: Int
k = Int -> SysrootUpgraderPullFlags
AnotherSysrootUpgraderPullFlags Int
k
instance P.Ord SysrootUpgraderPullFlags where
compare :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Ordering
compare a :: SysrootUpgraderPullFlags
a b :: 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
| 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 SysrootUpgraderFlagsIgnoreUnconfigured = 2
fromEnum (AnotherSysrootUpgraderFlags k :: Int
k) = Int
k
toEnum :: Int -> SysrootUpgraderFlags
toEnum 2 = SysrootUpgraderFlags
SysrootUpgraderFlagsIgnoreUnconfigured
toEnum k :: Int
k = Int -> SysrootUpgraderFlags
AnotherSysrootUpgraderFlags Int
k
instance P.Ord SysrootUpgraderFlags where
compare :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Ordering
compare a :: SysrootUpgraderFlags
a b :: 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 SysrootSimpleWriteDeploymentFlagsNone = 0
fromEnum SysrootSimpleWriteDeploymentFlagsRetain = 1
fromEnum SysrootSimpleWriteDeploymentFlagsNotDefault = 2
fromEnum SysrootSimpleWriteDeploymentFlagsNoClean = 4
fromEnum SysrootSimpleWriteDeploymentFlagsRetainPending = 8
fromEnum SysrootSimpleWriteDeploymentFlagsRetainRollback = 16
fromEnum (AnotherSysrootSimpleWriteDeploymentFlags k :: Int
k) = Int
k
toEnum :: Int -> SysrootSimpleWriteDeploymentFlags
toEnum 0 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNone
toEnum 1 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetain
toEnum 2 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNotDefault
toEnum 4 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNoClean
toEnum 8 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainPending
toEnum 16 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainRollback
toEnum k :: Int
k = Int -> SysrootSimpleWriteDeploymentFlags
AnotherSysrootSimpleWriteDeploymentFlags Int
k
instance P.Ord SysrootSimpleWriteDeploymentFlags where
compare :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Ordering
compare a :: SysrootSimpleWriteDeploymentFlags
a b :: 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 SePolicyRestoreconFlagsNone = 0
fromEnum SePolicyRestoreconFlagsAllowNolabel = 1
fromEnum SePolicyRestoreconFlagsKeepExisting = 2
fromEnum (AnotherSePolicyRestoreconFlags k :: Int
k) = Int
k
toEnum :: Int -> SePolicyRestoreconFlags
toEnum 0 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsNone
toEnum 1 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsAllowNolabel
toEnum 2 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsKeepExisting
toEnum k :: Int
k = Int -> SePolicyRestoreconFlags
AnotherSePolicyRestoreconFlags Int
k
instance P.Ord SePolicyRestoreconFlags where
compare :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Ordering
compare a :: SePolicyRestoreconFlags
a b :: 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 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 RepoResolveRevExtFlagsNone = 0
fromEnum RepoResolveRevExtFlagsLocalOnly = 1
fromEnum (AnotherRepoResolveRevExtFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoResolveRevExtFlags
toEnum 0 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsNone
toEnum 1 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsLocalOnly
toEnum k :: Int
k = Int -> RepoResolveRevExtFlags
AnotherRepoResolveRevExtFlags Int
k
instance P.Ord RepoResolveRevExtFlags where
compare :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Ordering
compare a :: RepoResolveRevExtFlags
a b :: 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 RepoPullFlagsNone = 0
fromEnum RepoPullFlagsMirror = 1
fromEnum RepoPullFlagsCommitOnly = 2
fromEnum RepoPullFlagsUntrusted = 4
fromEnum RepoPullFlagsBareuseronlyFiles = 8
fromEnum RepoPullFlagsTrustedHttp = 16
fromEnum (AnotherRepoPullFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoPullFlags
toEnum 0 = RepoPullFlags
RepoPullFlagsNone
toEnum 1 = RepoPullFlags
RepoPullFlagsMirror
toEnum 2 = RepoPullFlags
RepoPullFlagsCommitOnly
toEnum 4 = RepoPullFlags
RepoPullFlagsUntrusted
toEnum 8 = RepoPullFlags
RepoPullFlagsBareuseronlyFiles
toEnum 16 = RepoPullFlags
RepoPullFlagsTrustedHttp
toEnum k :: Int
k = Int -> RepoPullFlags
AnotherRepoPullFlags Int
k
instance P.Ord RepoPullFlags where
compare :: RepoPullFlags -> RepoPullFlags -> Ordering
compare a :: RepoPullFlags
a b :: 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 RepoPruneFlagsNone = 0
fromEnum RepoPruneFlagsNoPrune = 1
fromEnum RepoPruneFlagsRefsOnly = 2
fromEnum (AnotherRepoPruneFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoPruneFlags
toEnum 0 = RepoPruneFlags
RepoPruneFlagsNone
toEnum 1 = RepoPruneFlags
RepoPruneFlagsNoPrune
toEnum 2 = RepoPruneFlags
RepoPruneFlagsRefsOnly
toEnum k :: Int
k = Int -> RepoPruneFlags
AnotherRepoPruneFlags Int
k
instance P.Ord RepoPruneFlags where
compare :: RepoPruneFlags -> RepoPruneFlags -> Ordering
compare a :: RepoPruneFlags
a b :: 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 RepoListRefsExtFlagsNone = 0
fromEnum RepoListRefsExtFlagsAliases = 1
fromEnum RepoListRefsExtFlagsExcludeRemotes = 2
fromEnum RepoListRefsExtFlagsExcludeMirrors = 4
fromEnum (AnotherRepoListRefsExtFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoListRefsExtFlags
toEnum 0 = RepoListRefsExtFlags
RepoListRefsExtFlagsNone
toEnum 1 = RepoListRefsExtFlags
RepoListRefsExtFlagsAliases
toEnum 2 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeRemotes
toEnum 4 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeMirrors
toEnum k :: Int
k = Int -> RepoListRefsExtFlags
AnotherRepoListRefsExtFlags Int
k
instance P.Ord RepoListRefsExtFlags where
compare :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Ordering
compare a :: RepoListRefsExtFlags
a b :: 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 RepoListObjectsFlagsLoose = 1
fromEnum RepoListObjectsFlagsPacked = 2
fromEnum RepoListObjectsFlagsAll = 4
fromEnum RepoListObjectsFlagsNoParents = 8
fromEnum (AnotherRepoListObjectsFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoListObjectsFlags
toEnum 1 = RepoListObjectsFlags
RepoListObjectsFlagsLoose
toEnum 2 = RepoListObjectsFlags
RepoListObjectsFlagsPacked
toEnum 4 = RepoListObjectsFlags
RepoListObjectsFlagsAll
toEnum 8 = RepoListObjectsFlags
RepoListObjectsFlagsNoParents
toEnum k :: Int
k = Int -> RepoListObjectsFlags
AnotherRepoListObjectsFlags Int
k
instance P.Ord RepoListObjectsFlags where
compare :: RepoListObjectsFlags -> RepoListObjectsFlags -> Ordering
compare a :: RepoListObjectsFlags
a b :: 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 RepoCommitTraverseFlagsRepoCommitTraverseFlagNone = 1
fromEnum (AnotherRepoCommitTraverseFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoCommitTraverseFlags
toEnum 1 = RepoCommitTraverseFlags
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone
toEnum k :: Int
k = Int -> RepoCommitTraverseFlags
AnotherRepoCommitTraverseFlags Int
k
instance P.Ord RepoCommitTraverseFlags where
compare :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Ordering
compare a :: RepoCommitTraverseFlags
a b :: 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 RepoCommitStateNormal = 0
fromEnum RepoCommitStatePartial = 1
fromEnum RepoCommitStateFsckPartial = 2
fromEnum (AnotherRepoCommitState k :: Int
k) = Int
k
toEnum :: Int -> RepoCommitState
toEnum 0 = RepoCommitState
RepoCommitStateNormal
toEnum 1 = RepoCommitState
RepoCommitStatePartial
toEnum 2 = RepoCommitState
RepoCommitStateFsckPartial
toEnum k :: Int
k = Int -> RepoCommitState
AnotherRepoCommitState Int
k
instance P.Ord RepoCommitState where
compare :: RepoCommitState -> RepoCommitState -> Ordering
compare a :: RepoCommitState
a b :: 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 RepoCommitModifierFlagsNone = 0
fromEnum RepoCommitModifierFlagsSkipXattrs = 1
fromEnum RepoCommitModifierFlagsGenerateSizes = 2
fromEnum RepoCommitModifierFlagsCanonicalPermissions = 4
fromEnum RepoCommitModifierFlagsErrorOnUnlabeled = 8
fromEnum RepoCommitModifierFlagsConsume = 16
fromEnum RepoCommitModifierFlagsDevinoCanonical = 32
fromEnum (AnotherRepoCommitModifierFlags k :: Int
k) = Int
k
toEnum :: Int -> RepoCommitModifierFlags
toEnum 0 = RepoCommitModifierFlags
RepoCommitModifierFlagsNone
toEnum 1 = RepoCommitModifierFlags
RepoCommitModifierFlagsSkipXattrs
toEnum 2 = RepoCommitModifierFlags
RepoCommitModifierFlagsGenerateSizes
toEnum 4 = RepoCommitModifierFlags
RepoCommitModifierFlagsCanonicalPermissions
toEnum 8 = RepoCommitModifierFlags
RepoCommitModifierFlagsErrorOnUnlabeled
toEnum 16 = RepoCommitModifierFlags
RepoCommitModifierFlagsConsume
toEnum 32 = RepoCommitModifierFlags
RepoCommitModifierFlagsDevinoCanonical
toEnum k :: Int
k = Int -> RepoCommitModifierFlags
AnotherRepoCommitModifierFlags Int
k
instance P.Ord RepoCommitModifierFlags where
compare :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Ordering
compare a :: RepoCommitModifierFlags
a b :: 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 GpgSignatureFormatFlagsGpgSignatureFormatDefault = 0
fromEnum (AnotherGpgSignatureFormatFlags k :: Int
k) = Int
k
toEnum :: Int -> GpgSignatureFormatFlags
toEnum 0 = GpgSignatureFormatFlags
GpgSignatureFormatFlagsGpgSignatureFormatDefault
toEnum k :: Int
k = Int -> GpgSignatureFormatFlags
AnotherGpgSignatureFormatFlags Int
k
instance P.Ord GpgSignatureFormatFlags where
compare :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Ordering
compare a :: GpgSignatureFormatFlags
a b :: 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 DiffFlagsNone = 0
fromEnum DiffFlagsIgnoreXattrs = 1
fromEnum (AnotherDiffFlags k :: Int
k) = Int
k
toEnum :: Int -> DiffFlags
toEnum 0 = DiffFlags
DiffFlagsNone
toEnum 1 = DiffFlags
DiffFlagsIgnoreXattrs
toEnum k :: Int
k = Int -> DiffFlags
AnotherDiffFlags Int
k
instance P.Ord DiffFlags where
compare :: DiffFlags -> DiffFlags -> Ordering
compare a :: DiffFlags
a b :: 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
| 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 ChecksumFlagsNone = 0
fromEnum ChecksumFlagsIgnoreXattrs = 1
fromEnum (AnotherChecksumFlags k :: Int
k) = Int
k
toEnum :: Int -> ChecksumFlags
toEnum 0 = ChecksumFlags
ChecksumFlagsNone
toEnum 1 = ChecksumFlags
ChecksumFlagsIgnoreXattrs
toEnum k :: Int
k = Int -> ChecksumFlags
AnotherChecksumFlags Int
k
instance P.Ord ChecksumFlags where
compare :: ChecksumFlags -> ChecksumFlags -> Ordering
compare a :: ChecksumFlags
a b :: 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