#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Enums
(
BranchType(..) ,
CloneLocal(..) ,
ConfigLevel(..) ,
DeltaType(..) ,
DiffBinaryType(..) ,
DiffFormatType(..) ,
DiffLineType(..) ,
Direction(..) ,
Error(..) ,
catchError ,
handleError ,
FileMode(..) ,
MergeFileFavor(..) ,
PackbuilderStage(..) ,
ProxyType(..) ,
RebaseOperationType(..) ,
RefType(..) ,
RemoteCompletionType(..) ,
RemoteDownloadTagsType(..) ,
ResetType(..) ,
StatusShow(..) ,
SubmoduleIgnore(..) ,
SubmoduleRecurse(..) ,
SubmoduleUpdate(..) ,
TreeWalkMode(..) ,
) 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 TreeWalkMode =
TreeWalkModePre
| TreeWalkModePost
| AnotherTreeWalkMode Int
deriving (Int -> TreeWalkMode -> ShowS
[TreeWalkMode] -> ShowS
TreeWalkMode -> String
(Int -> TreeWalkMode -> ShowS)
-> (TreeWalkMode -> String)
-> ([TreeWalkMode] -> ShowS)
-> Show TreeWalkMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeWalkMode] -> ShowS
$cshowList :: [TreeWalkMode] -> ShowS
show :: TreeWalkMode -> String
$cshow :: TreeWalkMode -> String
showsPrec :: Int -> TreeWalkMode -> ShowS
$cshowsPrec :: Int -> TreeWalkMode -> ShowS
Show, TreeWalkMode -> TreeWalkMode -> Bool
(TreeWalkMode -> TreeWalkMode -> Bool)
-> (TreeWalkMode -> TreeWalkMode -> Bool) -> Eq TreeWalkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeWalkMode -> TreeWalkMode -> Bool
$c/= :: TreeWalkMode -> TreeWalkMode -> Bool
== :: TreeWalkMode -> TreeWalkMode -> Bool
$c== :: TreeWalkMode -> TreeWalkMode -> Bool
Eq)
instance P.Enum TreeWalkMode where
fromEnum :: TreeWalkMode -> Int
fromEnum TreeWalkMode
TreeWalkModePre = Int
0
fromEnum TreeWalkMode
TreeWalkModePost = Int
1
fromEnum (AnotherTreeWalkMode Int
k) = Int
k
toEnum :: Int -> TreeWalkMode
toEnum Int
0 = TreeWalkMode
TreeWalkModePre
toEnum Int
1 = TreeWalkMode
TreeWalkModePost
toEnum Int
k = Int -> TreeWalkMode
AnotherTreeWalkMode Int
k
instance P.Ord TreeWalkMode where
compare :: TreeWalkMode -> TreeWalkMode -> Ordering
compare TreeWalkMode
a TreeWalkMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeWalkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeWalkMode
a) (TreeWalkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeWalkMode
b)
type instance O.ParentTypes TreeWalkMode = '[]
instance O.HasParentTypes TreeWalkMode
foreign import ccall "ggit_tree_walk_mode_get_type" c_ggit_tree_walk_mode_get_type ::
IO GType
instance B.Types.TypedObject TreeWalkMode where
glibType :: IO GType
glibType = IO GType
c_ggit_tree_walk_mode_get_type
instance B.Types.BoxedEnum TreeWalkMode
data SubmoduleUpdate =
SubmoduleUpdateCheckout
| SubmoduleUpdateRebase
| SubmoduleUpdateMerge
| SubmoduleUpdateNone
| SubmoduleUpdateDefault
| AnotherSubmoduleUpdate Int
deriving (Int -> SubmoduleUpdate -> ShowS
[SubmoduleUpdate] -> ShowS
SubmoduleUpdate -> String
(Int -> SubmoduleUpdate -> ShowS)
-> (SubmoduleUpdate -> String)
-> ([SubmoduleUpdate] -> ShowS)
-> Show SubmoduleUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubmoduleUpdate] -> ShowS
$cshowList :: [SubmoduleUpdate] -> ShowS
show :: SubmoduleUpdate -> String
$cshow :: SubmoduleUpdate -> String
showsPrec :: Int -> SubmoduleUpdate -> ShowS
$cshowsPrec :: Int -> SubmoduleUpdate -> ShowS
Show, SubmoduleUpdate -> SubmoduleUpdate -> Bool
(SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> (SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> Eq SubmoduleUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
$c/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
$c== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
Eq)
instance P.Enum SubmoduleUpdate where
fromEnum :: SubmoduleUpdate -> Int
fromEnum SubmoduleUpdate
SubmoduleUpdateCheckout = Int
1
fromEnum SubmoduleUpdate
SubmoduleUpdateRebase = Int
2
fromEnum SubmoduleUpdate
SubmoduleUpdateMerge = Int
3
fromEnum SubmoduleUpdate
SubmoduleUpdateNone = Int
4
fromEnum SubmoduleUpdate
SubmoduleUpdateDefault = Int
0
fromEnum (AnotherSubmoduleUpdate Int
k) = Int
k
toEnum :: Int -> SubmoduleUpdate
toEnum Int
1 = SubmoduleUpdate
SubmoduleUpdateCheckout
toEnum Int
2 = SubmoduleUpdate
SubmoduleUpdateRebase
toEnum Int
3 = SubmoduleUpdate
SubmoduleUpdateMerge
toEnum Int
4 = SubmoduleUpdate
SubmoduleUpdateNone
toEnum Int
0 = SubmoduleUpdate
SubmoduleUpdateDefault
toEnum Int
k = Int -> SubmoduleUpdate
AnotherSubmoduleUpdate Int
k
instance P.Ord SubmoduleUpdate where
compare :: SubmoduleUpdate -> SubmoduleUpdate -> Ordering
compare SubmoduleUpdate
a SubmoduleUpdate
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleUpdate -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleUpdate
a) (SubmoduleUpdate -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleUpdate
b)
type instance O.ParentTypes SubmoduleUpdate = '[]
instance O.HasParentTypes SubmoduleUpdate
foreign import ccall "ggit_submodule_update_get_type" c_ggit_submodule_update_get_type ::
IO GType
instance B.Types.TypedObject SubmoduleUpdate where
glibType :: IO GType
glibType = IO GType
c_ggit_submodule_update_get_type
instance B.Types.BoxedEnum SubmoduleUpdate
data SubmoduleRecurse =
SubmoduleRecurseNo
| SubmoduleRecurseYes
| SubmoduleRecurseOndemand
| AnotherSubmoduleRecurse Int
deriving (Int -> SubmoduleRecurse -> ShowS
[SubmoduleRecurse] -> ShowS
SubmoduleRecurse -> String
(Int -> SubmoduleRecurse -> ShowS)
-> (SubmoduleRecurse -> String)
-> ([SubmoduleRecurse] -> ShowS)
-> Show SubmoduleRecurse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubmoduleRecurse] -> ShowS
$cshowList :: [SubmoduleRecurse] -> ShowS
show :: SubmoduleRecurse -> String
$cshow :: SubmoduleRecurse -> String
showsPrec :: Int -> SubmoduleRecurse -> ShowS
$cshowsPrec :: Int -> SubmoduleRecurse -> ShowS
Show, SubmoduleRecurse -> SubmoduleRecurse -> Bool
(SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> (SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> Eq SubmoduleRecurse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
$c/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
$c== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
Eq)
instance P.Enum SubmoduleRecurse where
fromEnum :: SubmoduleRecurse -> Int
fromEnum SubmoduleRecurse
SubmoduleRecurseNo = Int
0
fromEnum SubmoduleRecurse
SubmoduleRecurseYes = Int
1
fromEnum SubmoduleRecurse
SubmoduleRecurseOndemand = Int
2
fromEnum (AnotherSubmoduleRecurse Int
k) = Int
k
toEnum :: Int -> SubmoduleRecurse
toEnum Int
0 = SubmoduleRecurse
SubmoduleRecurseNo
toEnum Int
1 = SubmoduleRecurse
SubmoduleRecurseYes
toEnum Int
2 = SubmoduleRecurse
SubmoduleRecurseOndemand
toEnum Int
k = Int -> SubmoduleRecurse
AnotherSubmoduleRecurse Int
k
instance P.Ord SubmoduleRecurse where
compare :: SubmoduleRecurse -> SubmoduleRecurse -> Ordering
compare SubmoduleRecurse
a SubmoduleRecurse
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleRecurse -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleRecurse
a) (SubmoduleRecurse -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleRecurse
b)
type instance O.ParentTypes SubmoduleRecurse = '[]
instance O.HasParentTypes SubmoduleRecurse
foreign import ccall "ggit_submodule_recurse_get_type" c_ggit_submodule_recurse_get_type ::
IO GType
instance B.Types.TypedObject SubmoduleRecurse where
glibType :: IO GType
glibType = IO GType
c_ggit_submodule_recurse_get_type
instance B.Types.BoxedEnum SubmoduleRecurse
data SubmoduleIgnore =
SubmoduleIgnoreUnspecified
| SubmoduleIgnoreNone
| SubmoduleIgnoreUntracked
| SubmoduleIgnoreDirty
| SubmoduleIgnoreAll
| AnotherSubmoduleIgnore Int
deriving (Int -> SubmoduleIgnore -> ShowS
[SubmoduleIgnore] -> ShowS
SubmoduleIgnore -> String
(Int -> SubmoduleIgnore -> ShowS)
-> (SubmoduleIgnore -> String)
-> ([SubmoduleIgnore] -> ShowS)
-> Show SubmoduleIgnore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubmoduleIgnore] -> ShowS
$cshowList :: [SubmoduleIgnore] -> ShowS
show :: SubmoduleIgnore -> String
$cshow :: SubmoduleIgnore -> String
showsPrec :: Int -> SubmoduleIgnore -> ShowS
$cshowsPrec :: Int -> SubmoduleIgnore -> ShowS
Show, SubmoduleIgnore -> SubmoduleIgnore -> Bool
(SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> (SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> Eq SubmoduleIgnore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
$c/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
$c== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
Eq)
instance P.Enum SubmoduleIgnore where
fromEnum :: SubmoduleIgnore -> Int
fromEnum SubmoduleIgnore
SubmoduleIgnoreUnspecified = Int
-1
fromEnum SubmoduleIgnore
SubmoduleIgnoreNone = Int
1
fromEnum SubmoduleIgnore
SubmoduleIgnoreUntracked = Int
2
fromEnum SubmoduleIgnore
SubmoduleIgnoreDirty = Int
3
fromEnum SubmoduleIgnore
SubmoduleIgnoreAll = Int
4
fromEnum (AnotherSubmoduleIgnore Int
k) = Int
k
toEnum :: Int -> SubmoduleIgnore
toEnum Int
-1 = SubmoduleIgnore
SubmoduleIgnoreUnspecified
toEnum Int
1 = SubmoduleIgnore
SubmoduleIgnoreNone
toEnum Int
2 = SubmoduleIgnore
SubmoduleIgnoreUntracked
toEnum Int
3 = SubmoduleIgnore
SubmoduleIgnoreDirty
toEnum Int
4 = SubmoduleIgnore
SubmoduleIgnoreAll
toEnum Int
k = Int -> SubmoduleIgnore
AnotherSubmoduleIgnore Int
k
instance P.Ord SubmoduleIgnore where
compare :: SubmoduleIgnore -> SubmoduleIgnore -> Ordering
compare SubmoduleIgnore
a SubmoduleIgnore
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleIgnore -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleIgnore
a) (SubmoduleIgnore -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleIgnore
b)
type instance O.ParentTypes SubmoduleIgnore = '[]
instance O.HasParentTypes SubmoduleIgnore
foreign import ccall "ggit_submodule_ignore_get_type" c_ggit_submodule_ignore_get_type ::
IO GType
instance B.Types.TypedObject SubmoduleIgnore where
glibType :: IO GType
glibType = IO GType
c_ggit_submodule_ignore_get_type
instance B.Types.BoxedEnum SubmoduleIgnore
data StatusShow =
StatusShowIndexAndWorkdir
| StatusShowIndexOnly
| StatusShowWorkdirOnly
| AnotherStatusShow Int
deriving (Int -> StatusShow -> ShowS
[StatusShow] -> ShowS
StatusShow -> String
(Int -> StatusShow -> ShowS)
-> (StatusShow -> String)
-> ([StatusShow] -> ShowS)
-> Show StatusShow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StatusShow] -> ShowS
$cshowList :: [StatusShow] -> ShowS
show :: StatusShow -> String
$cshow :: StatusShow -> String
showsPrec :: Int -> StatusShow -> ShowS
$cshowsPrec :: Int -> StatusShow -> ShowS
Show, StatusShow -> StatusShow -> Bool
(StatusShow -> StatusShow -> Bool)
-> (StatusShow -> StatusShow -> Bool) -> Eq StatusShow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusShow -> StatusShow -> Bool
$c/= :: StatusShow -> StatusShow -> Bool
== :: StatusShow -> StatusShow -> Bool
$c== :: StatusShow -> StatusShow -> Bool
Eq)
instance P.Enum StatusShow where
fromEnum :: StatusShow -> Int
fromEnum StatusShow
StatusShowIndexAndWorkdir = Int
0
fromEnum StatusShow
StatusShowIndexOnly = Int
1
fromEnum StatusShow
StatusShowWorkdirOnly = Int
2
fromEnum (AnotherStatusShow Int
k) = Int
k
toEnum :: Int -> StatusShow
toEnum Int
0 = StatusShow
StatusShowIndexAndWorkdir
toEnum Int
1 = StatusShow
StatusShowIndexOnly
toEnum Int
2 = StatusShow
StatusShowWorkdirOnly
toEnum Int
k = Int -> StatusShow
AnotherStatusShow Int
k
instance P.Ord StatusShow where
compare :: StatusShow -> StatusShow -> Ordering
compare StatusShow
a StatusShow
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StatusShow -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusShow
a) (StatusShow -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusShow
b)
type instance O.ParentTypes StatusShow = '[]
instance O.HasParentTypes StatusShow
foreign import ccall "ggit_status_show_get_type" c_ggit_status_show_get_type ::
IO GType
instance B.Types.TypedObject StatusShow where
glibType :: IO GType
glibType = IO GType
c_ggit_status_show_get_type
instance B.Types.BoxedEnum StatusShow
data ResetType =
ResetTypeSoft
| ResetTypeMixed
| ResetTypeHard
| AnotherResetType Int
deriving (Int -> ResetType -> ShowS
[ResetType] -> ShowS
ResetType -> String
(Int -> ResetType -> ShowS)
-> (ResetType -> String)
-> ([ResetType] -> ShowS)
-> Show ResetType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResetType] -> ShowS
$cshowList :: [ResetType] -> ShowS
show :: ResetType -> String
$cshow :: ResetType -> String
showsPrec :: Int -> ResetType -> ShowS
$cshowsPrec :: Int -> ResetType -> ShowS
Show, ResetType -> ResetType -> Bool
(ResetType -> ResetType -> Bool)
-> (ResetType -> ResetType -> Bool) -> Eq ResetType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResetType -> ResetType -> Bool
$c/= :: ResetType -> ResetType -> Bool
== :: ResetType -> ResetType -> Bool
$c== :: ResetType -> ResetType -> Bool
Eq)
instance P.Enum ResetType where
fromEnum :: ResetType -> Int
fromEnum ResetType
ResetTypeSoft = Int
1
fromEnum ResetType
ResetTypeMixed = Int
2
fromEnum ResetType
ResetTypeHard = Int
3
fromEnum (AnotherResetType Int
k) = Int
k
toEnum :: Int -> ResetType
toEnum Int
1 = ResetType
ResetTypeSoft
toEnum Int
2 = ResetType
ResetTypeMixed
toEnum Int
3 = ResetType
ResetTypeHard
toEnum Int
k = Int -> ResetType
AnotherResetType Int
k
instance P.Ord ResetType where
compare :: ResetType -> ResetType -> Ordering
compare ResetType
a ResetType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResetType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResetType
a) (ResetType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResetType
b)
type instance O.ParentTypes ResetType = '[]
instance O.HasParentTypes ResetType
foreign import ccall "ggit_reset_type_get_type" c_ggit_reset_type_get_type ::
IO GType
instance B.Types.TypedObject ResetType where
glibType :: IO GType
glibType = IO GType
c_ggit_reset_type_get_type
instance B.Types.BoxedEnum ResetType
data RemoteDownloadTagsType =
RemoteDownloadTagsTypeUnspecified
| RemoteDownloadTagsTypeAuto
| RemoteDownloadTagsTypeNone
| RemoteDownloadTagsTypeAll
| AnotherRemoteDownloadTagsType Int
deriving (Int -> RemoteDownloadTagsType -> ShowS
[RemoteDownloadTagsType] -> ShowS
RemoteDownloadTagsType -> String
(Int -> RemoteDownloadTagsType -> ShowS)
-> (RemoteDownloadTagsType -> String)
-> ([RemoteDownloadTagsType] -> ShowS)
-> Show RemoteDownloadTagsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoteDownloadTagsType] -> ShowS
$cshowList :: [RemoteDownloadTagsType] -> ShowS
show :: RemoteDownloadTagsType -> String
$cshow :: RemoteDownloadTagsType -> String
showsPrec :: Int -> RemoteDownloadTagsType -> ShowS
$cshowsPrec :: Int -> RemoteDownloadTagsType -> ShowS
Show, RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
(RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> (RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> Eq RemoteDownloadTagsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
$c/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
$c== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
Eq)
instance P.Enum RemoteDownloadTagsType where
fromEnum :: RemoteDownloadTagsType -> Int
fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeUnspecified = Int
0
fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeAuto = Int
1
fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeNone = Int
2
fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeAll = Int
3
fromEnum (AnotherRemoteDownloadTagsType Int
k) = Int
k
toEnum :: Int -> RemoteDownloadTagsType
toEnum Int
0 = RemoteDownloadTagsType
RemoteDownloadTagsTypeUnspecified
toEnum Int
1 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAuto
toEnum Int
2 = RemoteDownloadTagsType
RemoteDownloadTagsTypeNone
toEnum Int
3 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAll
toEnum Int
k = Int -> RemoteDownloadTagsType
AnotherRemoteDownloadTagsType Int
k
instance P.Ord RemoteDownloadTagsType where
compare :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Ordering
compare RemoteDownloadTagsType
a RemoteDownloadTagsType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RemoteDownloadTagsType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteDownloadTagsType
a) (RemoteDownloadTagsType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteDownloadTagsType
b)
type instance O.ParentTypes RemoteDownloadTagsType = '[]
instance O.HasParentTypes RemoteDownloadTagsType
foreign import ccall "ggit_remote_download_tags_type_get_type" c_ggit_remote_download_tags_type_get_type ::
IO GType
instance B.Types.TypedObject RemoteDownloadTagsType where
glibType :: IO GType
glibType = IO GType
c_ggit_remote_download_tags_type_get_type
instance B.Types.BoxedEnum RemoteDownloadTagsType
data RemoteCompletionType =
RemoteCompletionTypeDownload
| RemoteCompletionTypeIndexing
| RemoteCompletionTypeError
| AnotherRemoteCompletionType Int
deriving (Int -> RemoteCompletionType -> ShowS
[RemoteCompletionType] -> ShowS
RemoteCompletionType -> String
(Int -> RemoteCompletionType -> ShowS)
-> (RemoteCompletionType -> String)
-> ([RemoteCompletionType] -> ShowS)
-> Show RemoteCompletionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoteCompletionType] -> ShowS
$cshowList :: [RemoteCompletionType] -> ShowS
show :: RemoteCompletionType -> String
$cshow :: RemoteCompletionType -> String
showsPrec :: Int -> RemoteCompletionType -> ShowS
$cshowsPrec :: Int -> RemoteCompletionType -> ShowS
Show, RemoteCompletionType -> RemoteCompletionType -> Bool
(RemoteCompletionType -> RemoteCompletionType -> Bool)
-> (RemoteCompletionType -> RemoteCompletionType -> Bool)
-> Eq RemoteCompletionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
$c/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
== :: RemoteCompletionType -> RemoteCompletionType -> Bool
$c== :: RemoteCompletionType -> RemoteCompletionType -> Bool
Eq)
instance P.Enum RemoteCompletionType where
fromEnum :: RemoteCompletionType -> Int
fromEnum RemoteCompletionType
RemoteCompletionTypeDownload = Int
0
fromEnum RemoteCompletionType
RemoteCompletionTypeIndexing = Int
1
fromEnum RemoteCompletionType
RemoteCompletionTypeError = Int
2
fromEnum (AnotherRemoteCompletionType Int
k) = Int
k
toEnum :: Int -> RemoteCompletionType
toEnum Int
0 = RemoteCompletionType
RemoteCompletionTypeDownload
toEnum Int
1 = RemoteCompletionType
RemoteCompletionTypeIndexing
toEnum Int
2 = RemoteCompletionType
RemoteCompletionTypeError
toEnum Int
k = Int -> RemoteCompletionType
AnotherRemoteCompletionType Int
k
instance P.Ord RemoteCompletionType where
compare :: RemoteCompletionType -> RemoteCompletionType -> Ordering
compare RemoteCompletionType
a RemoteCompletionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RemoteCompletionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteCompletionType
a) (RemoteCompletionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteCompletionType
b)
type instance O.ParentTypes RemoteCompletionType = '[]
instance O.HasParentTypes RemoteCompletionType
foreign import ccall "ggit_remote_completion_type_get_type" c_ggit_remote_completion_type_get_type ::
IO GType
instance B.Types.TypedObject RemoteCompletionType where
glibType :: IO GType
glibType = IO GType
c_ggit_remote_completion_type_get_type
instance B.Types.BoxedEnum RemoteCompletionType
data RefType =
RefTypeInvalid
| RefTypeOid
| RefTypeSymbolic
| RefTypeListall
| AnotherRefType Int
deriving (Int -> RefType -> ShowS
[RefType] -> ShowS
RefType -> String
(Int -> RefType -> ShowS)
-> (RefType -> String) -> ([RefType] -> ShowS) -> Show RefType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RefType] -> ShowS
$cshowList :: [RefType] -> ShowS
show :: RefType -> String
$cshow :: RefType -> String
showsPrec :: Int -> RefType -> ShowS
$cshowsPrec :: Int -> RefType -> ShowS
Show, RefType -> RefType -> Bool
(RefType -> RefType -> Bool)
-> (RefType -> RefType -> Bool) -> Eq RefType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RefType -> RefType -> Bool
$c/= :: RefType -> RefType -> Bool
== :: RefType -> RefType -> Bool
$c== :: RefType -> RefType -> Bool
Eq)
instance P.Enum RefType where
fromEnum :: RefType -> Int
fromEnum RefType
RefTypeInvalid = Int
0
fromEnum RefType
RefTypeOid = Int
1
fromEnum RefType
RefTypeSymbolic = Int
2
fromEnum RefType
RefTypeListall = Int
3
fromEnum (AnotherRefType Int
k) = Int
k
toEnum :: Int -> RefType
toEnum Int
0 = RefType
RefTypeInvalid
toEnum Int
1 = RefType
RefTypeOid
toEnum Int
2 = RefType
RefTypeSymbolic
toEnum Int
3 = RefType
RefTypeListall
toEnum Int
k = Int -> RefType
AnotherRefType Int
k
instance P.Ord RefType where
compare :: RefType -> RefType -> Ordering
compare RefType
a RefType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RefType -> Int
forall a. Enum a => a -> Int
P.fromEnum RefType
a) (RefType -> Int
forall a. Enum a => a -> Int
P.fromEnum RefType
b)
type instance O.ParentTypes RefType = '[]
instance O.HasParentTypes RefType
foreign import ccall "ggit_ref_type_get_type" c_ggit_ref_type_get_type ::
IO GType
instance B.Types.TypedObject RefType where
glibType :: IO GType
glibType = IO GType
c_ggit_ref_type_get_type
instance B.Types.BoxedEnum RefType
data RebaseOperationType =
RebaseOperationTypePick
| RebaseOperationTypeReword
| RebaseOperationTypeEdit
| RebaseOperationTypeSquash
| RebaseOperationTypeFixup
| RebaseOperationTypeExec
| AnotherRebaseOperationType Int
deriving (Int -> RebaseOperationType -> ShowS
[RebaseOperationType] -> ShowS
RebaseOperationType -> String
(Int -> RebaseOperationType -> ShowS)
-> (RebaseOperationType -> String)
-> ([RebaseOperationType] -> ShowS)
-> Show RebaseOperationType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RebaseOperationType] -> ShowS
$cshowList :: [RebaseOperationType] -> ShowS
show :: RebaseOperationType -> String
$cshow :: RebaseOperationType -> String
showsPrec :: Int -> RebaseOperationType -> ShowS
$cshowsPrec :: Int -> RebaseOperationType -> ShowS
Show, RebaseOperationType -> RebaseOperationType -> Bool
(RebaseOperationType -> RebaseOperationType -> Bool)
-> (RebaseOperationType -> RebaseOperationType -> Bool)
-> Eq RebaseOperationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RebaseOperationType -> RebaseOperationType -> Bool
$c/= :: RebaseOperationType -> RebaseOperationType -> Bool
== :: RebaseOperationType -> RebaseOperationType -> Bool
$c== :: RebaseOperationType -> RebaseOperationType -> Bool
Eq)
instance P.Enum RebaseOperationType where
fromEnum :: RebaseOperationType -> Int
fromEnum RebaseOperationType
RebaseOperationTypePick = Int
0
fromEnum RebaseOperationType
RebaseOperationTypeReword = Int
1
fromEnum RebaseOperationType
RebaseOperationTypeEdit = Int
2
fromEnum RebaseOperationType
RebaseOperationTypeSquash = Int
3
fromEnum RebaseOperationType
RebaseOperationTypeFixup = Int
4
fromEnum RebaseOperationType
RebaseOperationTypeExec = Int
5
fromEnum (AnotherRebaseOperationType Int
k) = Int
k
toEnum :: Int -> RebaseOperationType
toEnum Int
0 = RebaseOperationType
RebaseOperationTypePick
toEnum Int
1 = RebaseOperationType
RebaseOperationTypeReword
toEnum Int
2 = RebaseOperationType
RebaseOperationTypeEdit
toEnum Int
3 = RebaseOperationType
RebaseOperationTypeSquash
toEnum Int
4 = RebaseOperationType
RebaseOperationTypeFixup
toEnum Int
5 = RebaseOperationType
RebaseOperationTypeExec
toEnum Int
k = Int -> RebaseOperationType
AnotherRebaseOperationType Int
k
instance P.Ord RebaseOperationType where
compare :: RebaseOperationType -> RebaseOperationType -> Ordering
compare RebaseOperationType
a RebaseOperationType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RebaseOperationType -> Int
forall a. Enum a => a -> Int
P.fromEnum RebaseOperationType
a) (RebaseOperationType -> Int
forall a. Enum a => a -> Int
P.fromEnum RebaseOperationType
b)
type instance O.ParentTypes RebaseOperationType = '[]
instance O.HasParentTypes RebaseOperationType
foreign import ccall "ggit_rebase_operation_type_get_type" c_ggit_rebase_operation_type_get_type ::
IO GType
instance B.Types.TypedObject RebaseOperationType where
glibType :: IO GType
glibType = IO GType
c_ggit_rebase_operation_type_get_type
instance B.Types.BoxedEnum RebaseOperationType
data ProxyType =
ProxyTypeNone
| ProxyTypeAuto
| ProxyTypeSpecified
| AnotherProxyType Int
deriving (Int -> ProxyType -> ShowS
[ProxyType] -> ShowS
ProxyType -> String
(Int -> ProxyType -> ShowS)
-> (ProxyType -> String)
-> ([ProxyType] -> ShowS)
-> Show ProxyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProxyType] -> ShowS
$cshowList :: [ProxyType] -> ShowS
show :: ProxyType -> String
$cshow :: ProxyType -> String
showsPrec :: Int -> ProxyType -> ShowS
$cshowsPrec :: Int -> ProxyType -> ShowS
Show, ProxyType -> ProxyType -> Bool
(ProxyType -> ProxyType -> Bool)
-> (ProxyType -> ProxyType -> Bool) -> Eq ProxyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProxyType -> ProxyType -> Bool
$c/= :: ProxyType -> ProxyType -> Bool
== :: ProxyType -> ProxyType -> Bool
$c== :: ProxyType -> ProxyType -> Bool
Eq)
instance P.Enum ProxyType where
fromEnum :: ProxyType -> Int
fromEnum ProxyType
ProxyTypeNone = Int
0
fromEnum ProxyType
ProxyTypeAuto = Int
1
fromEnum ProxyType
ProxyTypeSpecified = Int
2
fromEnum (AnotherProxyType Int
k) = Int
k
toEnum :: Int -> ProxyType
toEnum Int
0 = ProxyType
ProxyTypeNone
toEnum Int
1 = ProxyType
ProxyTypeAuto
toEnum Int
2 = ProxyType
ProxyTypeSpecified
toEnum Int
k = Int -> ProxyType
AnotherProxyType Int
k
instance P.Ord ProxyType where
compare :: ProxyType -> ProxyType -> Ordering
compare ProxyType
a ProxyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ProxyType -> Int
forall a. Enum a => a -> Int
P.fromEnum ProxyType
a) (ProxyType -> Int
forall a. Enum a => a -> Int
P.fromEnum ProxyType
b)
type instance O.ParentTypes ProxyType = '[]
instance O.HasParentTypes ProxyType
foreign import ccall "ggit_proxy_type_get_type" c_ggit_proxy_type_get_type ::
IO GType
instance B.Types.TypedObject ProxyType where
glibType :: IO GType
glibType = IO GType
c_ggit_proxy_type_get_type
instance B.Types.BoxedEnum ProxyType
data PackbuilderStage =
PackbuilderStageAddingObjects
| PackbuilderStageDeltafication
| AnotherPackbuilderStage Int
deriving (Int -> PackbuilderStage -> ShowS
[PackbuilderStage] -> ShowS
PackbuilderStage -> String
(Int -> PackbuilderStage -> ShowS)
-> (PackbuilderStage -> String)
-> ([PackbuilderStage] -> ShowS)
-> Show PackbuilderStage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackbuilderStage] -> ShowS
$cshowList :: [PackbuilderStage] -> ShowS
show :: PackbuilderStage -> String
$cshow :: PackbuilderStage -> String
showsPrec :: Int -> PackbuilderStage -> ShowS
$cshowsPrec :: Int -> PackbuilderStage -> ShowS
Show, PackbuilderStage -> PackbuilderStage -> Bool
(PackbuilderStage -> PackbuilderStage -> Bool)
-> (PackbuilderStage -> PackbuilderStage -> Bool)
-> Eq PackbuilderStage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackbuilderStage -> PackbuilderStage -> Bool
$c/= :: PackbuilderStage -> PackbuilderStage -> Bool
== :: PackbuilderStage -> PackbuilderStage -> Bool
$c== :: PackbuilderStage -> PackbuilderStage -> Bool
Eq)
instance P.Enum PackbuilderStage where
fromEnum :: PackbuilderStage -> Int
fromEnum PackbuilderStage
PackbuilderStageAddingObjects = Int
0
fromEnum PackbuilderStage
PackbuilderStageDeltafication = Int
1
fromEnum (AnotherPackbuilderStage Int
k) = Int
k
toEnum :: Int -> PackbuilderStage
toEnum Int
0 = PackbuilderStage
PackbuilderStageAddingObjects
toEnum Int
1 = PackbuilderStage
PackbuilderStageDeltafication
toEnum Int
k = Int -> PackbuilderStage
AnotherPackbuilderStage Int
k
instance P.Ord PackbuilderStage where
compare :: PackbuilderStage -> PackbuilderStage -> Ordering
compare PackbuilderStage
a PackbuilderStage
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PackbuilderStage -> Int
forall a. Enum a => a -> Int
P.fromEnum PackbuilderStage
a) (PackbuilderStage -> Int
forall a. Enum a => a -> Int
P.fromEnum PackbuilderStage
b)
type instance O.ParentTypes PackbuilderStage = '[]
instance O.HasParentTypes PackbuilderStage
foreign import ccall "ggit_packbuilder_stage_get_type" c_ggit_packbuilder_stage_get_type ::
IO GType
instance B.Types.TypedObject PackbuilderStage where
glibType :: IO GType
glibType = IO GType
c_ggit_packbuilder_stage_get_type
instance B.Types.BoxedEnum PackbuilderStage
data MergeFileFavor =
MergeFileFavorNormal
| MergeFileFavorOurs
| MergeFileFavorTheirs
| MergeFileFavorUnion
| AnotherMergeFileFavor Int
deriving (Int -> MergeFileFavor -> ShowS
[MergeFileFavor] -> ShowS
MergeFileFavor -> String
(Int -> MergeFileFavor -> ShowS)
-> (MergeFileFavor -> String)
-> ([MergeFileFavor] -> ShowS)
-> Show MergeFileFavor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MergeFileFavor] -> ShowS
$cshowList :: [MergeFileFavor] -> ShowS
show :: MergeFileFavor -> String
$cshow :: MergeFileFavor -> String
showsPrec :: Int -> MergeFileFavor -> ShowS
$cshowsPrec :: Int -> MergeFileFavor -> ShowS
Show, MergeFileFavor -> MergeFileFavor -> Bool
(MergeFileFavor -> MergeFileFavor -> Bool)
-> (MergeFileFavor -> MergeFileFavor -> Bool) -> Eq MergeFileFavor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MergeFileFavor -> MergeFileFavor -> Bool
$c/= :: MergeFileFavor -> MergeFileFavor -> Bool
== :: MergeFileFavor -> MergeFileFavor -> Bool
$c== :: MergeFileFavor -> MergeFileFavor -> Bool
Eq)
instance P.Enum MergeFileFavor where
fromEnum :: MergeFileFavor -> Int
fromEnum MergeFileFavor
MergeFileFavorNormal = Int
0
fromEnum MergeFileFavor
MergeFileFavorOurs = Int
1
fromEnum MergeFileFavor
MergeFileFavorTheirs = Int
2
fromEnum MergeFileFavor
MergeFileFavorUnion = Int
3
fromEnum (AnotherMergeFileFavor Int
k) = Int
k
toEnum :: Int -> MergeFileFavor
toEnum Int
0 = MergeFileFavor
MergeFileFavorNormal
toEnum Int
1 = MergeFileFavor
MergeFileFavorOurs
toEnum Int
2 = MergeFileFavor
MergeFileFavorTheirs
toEnum Int
3 = MergeFileFavor
MergeFileFavorUnion
toEnum Int
k = Int -> MergeFileFavor
AnotherMergeFileFavor Int
k
instance P.Ord MergeFileFavor where
compare :: MergeFileFavor -> MergeFileFavor -> Ordering
compare MergeFileFavor
a MergeFileFavor
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MergeFileFavor -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFavor
a) (MergeFileFavor -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFavor
b)
type instance O.ParentTypes MergeFileFavor = '[]
instance O.HasParentTypes MergeFileFavor
foreign import ccall "ggit_merge_file_favor_get_type" c_ggit_merge_file_favor_get_type ::
IO GType
instance B.Types.TypedObject MergeFileFavor where
glibType :: IO GType
glibType = IO GType
c_ggit_merge_file_favor_get_type
instance B.Types.BoxedEnum MergeFileFavor
data FileMode =
FileModeUnreadable
| FileModeTree
| FileModeBlob
| FileModeBlobExecutable
| FileModeLink
| FileModeCommit
| AnotherFileMode Int
deriving (Int -> FileMode -> ShowS
[FileMode] -> ShowS
FileMode -> String
(Int -> FileMode -> ShowS)
-> (FileMode -> String) -> ([FileMode] -> ShowS) -> Show FileMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileMode] -> ShowS
$cshowList :: [FileMode] -> ShowS
show :: FileMode -> String
$cshow :: FileMode -> String
showsPrec :: Int -> FileMode -> ShowS
$cshowsPrec :: Int -> FileMode -> ShowS
Show, FileMode -> FileMode -> Bool
(FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool) -> Eq FileMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileMode -> FileMode -> Bool
$c/= :: FileMode -> FileMode -> Bool
== :: FileMode -> FileMode -> Bool
$c== :: FileMode -> FileMode -> Bool
Eq)
instance P.Enum FileMode where
fromEnum :: FileMode -> Int
fromEnum FileMode
FileModeUnreadable = Int
0
fromEnum FileMode
FileModeTree = Int
16384
fromEnum FileMode
FileModeBlob = Int
33188
fromEnum FileMode
FileModeBlobExecutable = Int
33261
fromEnum FileMode
FileModeLink = Int
40960
fromEnum FileMode
FileModeCommit = Int
57344
fromEnum (AnotherFileMode Int
k) = Int
k
toEnum :: Int -> FileMode
toEnum Int
0 = FileMode
FileModeUnreadable
toEnum Int
16384 = FileMode
FileModeTree
toEnum Int
33188 = FileMode
FileModeBlob
toEnum Int
33261 = FileMode
FileModeBlobExecutable
toEnum Int
40960 = FileMode
FileModeLink
toEnum Int
57344 = FileMode
FileModeCommit
toEnum Int
k = Int -> FileMode
AnotherFileMode Int
k
instance P.Ord FileMode where
compare :: FileMode -> FileMode -> Ordering
compare FileMode
a FileMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMode
a) (FileMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMode
b)
type instance O.ParentTypes FileMode = '[]
instance O.HasParentTypes FileMode
foreign import ccall "ggit_file_mode_get_type" c_ggit_file_mode_get_type ::
IO GType
instance B.Types.TypedObject FileMode where
glibType :: IO GType
glibType = IO GType
c_ggit_file_mode_get_type
instance B.Types.BoxedEnum FileMode
data Error =
ErrorGitError
| ErrorNotfound
| ErrorExists
| ErrorAmbiguous
| ErrorBufs
| ErrorPassthrough
| ErrorIterover
| AnotherError Int
deriving (Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
(Int -> Error -> ShowS)
-> (Error -> String) -> ([Error] -> ShowS) -> Show Error
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Error] -> ShowS
$cshowList :: [Error] -> ShowS
show :: Error -> String
$cshow :: Error -> String
showsPrec :: Int -> Error -> ShowS
$cshowsPrec :: Int -> Error -> ShowS
Show, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c== :: Error -> Error -> Bool
Eq)
instance P.Enum Error where
fromEnum :: Error -> Int
fromEnum Error
ErrorGitError = Int
-1
fromEnum Error
ErrorNotfound = Int
-3
fromEnum Error
ErrorExists = Int
-4
fromEnum Error
ErrorAmbiguous = Int
-5
fromEnum Error
ErrorBufs = Int
-6
fromEnum Error
ErrorPassthrough = Int
-30
fromEnum Error
ErrorIterover = Int
-31
fromEnum (AnotherError Int
k) = Int
k
toEnum :: Int -> Error
toEnum Int
-1 = Error
ErrorGitError
toEnum Int
-3 = Error
ErrorNotfound
toEnum Int
-4 = Error
ErrorExists
toEnum Int
-5 = Error
ErrorAmbiguous
toEnum Int
-6 = Error
ErrorBufs
toEnum Int
-30 = Error
ErrorPassthrough
toEnum Int
-31 = Error
ErrorIterover
toEnum Int
k = Int -> Error
AnotherError Int
k
instance P.Ord Error where
compare :: Error -> Error -> Ordering
compare Error
a Error
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
a) (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
b)
instance GErrorClass Error where
gerrorClassDomain :: Error -> Text
gerrorClassDomain Error
_ = Text
"ggit-error"
catchError ::
IO a ->
(Error -> GErrorMessage -> IO a) ->
IO a
catchError :: forall a. IO a -> (Error -> Text -> IO a) -> IO a
catchError = IO a -> (Error -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleError ::
(Error -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleError :: forall a. (Error -> Text -> IO a) -> IO a -> IO a
handleError = (Error -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes Error = '[]
instance O.HasParentTypes Error
foreign import ccall "ggit_error_get_type" c_ggit_error_get_type ::
IO GType
instance B.Types.TypedObject Error where
glibType :: IO GType
glibType = IO GType
c_ggit_error_get_type
instance B.Types.BoxedEnum Error
data Direction =
DirectionFetch
| DirectionPush
| AnotherDirection Int
deriving (Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
(Int -> Direction -> ShowS)
-> (Direction -> String)
-> ([Direction] -> ShowS)
-> Show Direction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Direction] -> ShowS
$cshowList :: [Direction] -> ShowS
show :: Direction -> String
$cshow :: Direction -> String
showsPrec :: Int -> Direction -> ShowS
$cshowsPrec :: Int -> Direction -> ShowS
Show, Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: Direction -> Direction -> Bool
Eq)
instance P.Enum Direction where
fromEnum :: Direction -> Int
fromEnum Direction
DirectionFetch = Int
0
fromEnum Direction
DirectionPush = Int
1
fromEnum (AnotherDirection Int
k) = Int
k
toEnum :: Int -> Direction
toEnum Int
0 = Direction
DirectionFetch
toEnum Int
1 = Direction
DirectionPush
toEnum Int
k = Int -> Direction
AnotherDirection Int
k
instance P.Ord Direction where
compare :: Direction -> Direction -> Ordering
compare Direction
a Direction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Direction -> Int
forall a. Enum a => a -> Int
P.fromEnum Direction
a) (Direction -> Int
forall a. Enum a => a -> Int
P.fromEnum Direction
b)
type instance O.ParentTypes Direction = '[]
instance O.HasParentTypes Direction
foreign import ccall "ggit_direction_get_type" c_ggit_direction_get_type ::
IO GType
instance B.Types.TypedObject Direction where
glibType :: IO GType
glibType = IO GType
c_ggit_direction_get_type
instance B.Types.BoxedEnum Direction
data DiffLineType =
DiffLineTypeContext
| DiffLineTypeAddition
| DiffLineTypeDeletion
| DiffLineTypeContextEofnl
| DiffLineTypeAddEofnl
| DiffLineTypeDelEofnl
| DiffLineTypeFileHdr
| DiffLineTypeHunkHdr
| DiffLineTypeBinary
| AnotherDiffLineType Int
deriving (Int -> DiffLineType -> ShowS
[DiffLineType] -> ShowS
DiffLineType -> String
(Int -> DiffLineType -> ShowS)
-> (DiffLineType -> String)
-> ([DiffLineType] -> ShowS)
-> Show DiffLineType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DiffLineType] -> ShowS
$cshowList :: [DiffLineType] -> ShowS
show :: DiffLineType -> String
$cshow :: DiffLineType -> String
showsPrec :: Int -> DiffLineType -> ShowS
$cshowsPrec :: Int -> DiffLineType -> ShowS
Show, DiffLineType -> DiffLineType -> Bool
(DiffLineType -> DiffLineType -> Bool)
-> (DiffLineType -> DiffLineType -> Bool) -> Eq DiffLineType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffLineType -> DiffLineType -> Bool
$c/= :: DiffLineType -> DiffLineType -> Bool
== :: DiffLineType -> DiffLineType -> Bool
$c== :: DiffLineType -> DiffLineType -> Bool
Eq)
instance P.Enum DiffLineType where
fromEnum :: DiffLineType -> Int
fromEnum DiffLineType
DiffLineTypeContext = Int
32
fromEnum DiffLineType
DiffLineTypeAddition = Int
43
fromEnum DiffLineType
DiffLineTypeDeletion = Int
45
fromEnum DiffLineType
DiffLineTypeContextEofnl = Int
61
fromEnum DiffLineType
DiffLineTypeAddEofnl = Int
62
fromEnum DiffLineType
DiffLineTypeDelEofnl = Int
60
fromEnum DiffLineType
DiffLineTypeFileHdr = Int
70
fromEnum DiffLineType
DiffLineTypeHunkHdr = Int
72
fromEnum DiffLineType
DiffLineTypeBinary = Int
66
fromEnum (AnotherDiffLineType Int
k) = Int
k
toEnum :: Int -> DiffLineType
toEnum Int
32 = DiffLineType
DiffLineTypeContext
toEnum Int
43 = DiffLineType
DiffLineTypeAddition
toEnum Int
45 = DiffLineType
DiffLineTypeDeletion
toEnum Int
61 = DiffLineType
DiffLineTypeContextEofnl
toEnum Int
62 = DiffLineType
DiffLineTypeAddEofnl
toEnum Int
60 = DiffLineType
DiffLineTypeDelEofnl
toEnum Int
70 = DiffLineType
DiffLineTypeFileHdr
toEnum Int
72 = DiffLineType
DiffLineTypeHunkHdr
toEnum Int
66 = DiffLineType
DiffLineTypeBinary
toEnum Int
k = Int -> DiffLineType
AnotherDiffLineType Int
k
instance P.Ord DiffLineType where
compare :: DiffLineType -> DiffLineType -> Ordering
compare DiffLineType
a DiffLineType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffLineType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffLineType
a) (DiffLineType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffLineType
b)
type instance O.ParentTypes DiffLineType = '[]
instance O.HasParentTypes DiffLineType
foreign import ccall "ggit_diff_line_type_get_type" c_ggit_diff_line_type_get_type ::
IO GType
instance B.Types.TypedObject DiffLineType where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_line_type_get_type
instance B.Types.BoxedEnum DiffLineType
data DiffFormatType =
DiffFormatTypePatch
|
| DiffFormatTypeRaw
| DiffFormatTypeNameOnly
| DiffFormatTypeNameStatus
| AnotherDiffFormatType Int
deriving (Int -> DiffFormatType -> ShowS
[DiffFormatType] -> ShowS
DiffFormatType -> String
(Int -> DiffFormatType -> ShowS)
-> (DiffFormatType -> String)
-> ([DiffFormatType] -> ShowS)
-> Show DiffFormatType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DiffFormatType] -> ShowS
$cshowList :: [DiffFormatType] -> ShowS
show :: DiffFormatType -> String
$cshow :: DiffFormatType -> String
showsPrec :: Int -> DiffFormatType -> ShowS
$cshowsPrec :: Int -> DiffFormatType -> ShowS
Show, DiffFormatType -> DiffFormatType -> Bool
(DiffFormatType -> DiffFormatType -> Bool)
-> (DiffFormatType -> DiffFormatType -> Bool) -> Eq DiffFormatType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFormatType -> DiffFormatType -> Bool
$c/= :: DiffFormatType -> DiffFormatType -> Bool
== :: DiffFormatType -> DiffFormatType -> Bool
$c== :: DiffFormatType -> DiffFormatType -> Bool
Eq)
instance P.Enum DiffFormatType where
fromEnum :: DiffFormatType -> Int
fromEnum DiffFormatType
DiffFormatTypePatch = Int
1
fromEnum DiffFormatType
DiffFormatTypePatchHeader = Int
2
fromEnum DiffFormatType
DiffFormatTypeRaw = Int
3
fromEnum DiffFormatType
DiffFormatTypeNameOnly = Int
4
fromEnum DiffFormatType
DiffFormatTypeNameStatus = Int
5
fromEnum (AnotherDiffFormatType Int
k) = Int
k
toEnum :: Int -> DiffFormatType
toEnum Int
1 = DiffFormatType
DiffFormatTypePatch
toEnum Int
2 = DiffFormatType
DiffFormatTypePatchHeader
toEnum Int
3 = DiffFormatType
DiffFormatTypeRaw
toEnum Int
4 = DiffFormatType
DiffFormatTypeNameOnly
toEnum Int
5 = DiffFormatType
DiffFormatTypeNameStatus
toEnum Int
k = Int -> DiffFormatType
AnotherDiffFormatType Int
k
instance P.Ord DiffFormatType where
compare :: DiffFormatType -> DiffFormatType -> Ordering
compare DiffFormatType
a DiffFormatType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFormatType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatType
a) (DiffFormatType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatType
b)
type instance O.ParentTypes DiffFormatType = '[]
instance O.HasParentTypes DiffFormatType
foreign import ccall "ggit_diff_format_type_get_type" c_ggit_diff_format_type_get_type ::
IO GType
instance B.Types.TypedObject DiffFormatType where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_format_type_get_type
instance B.Types.BoxedEnum DiffFormatType
data DiffBinaryType =
DiffBinaryTypeNone
| DiffBinaryTypeLiteral
| DiffBinaryTypeDelta
| AnotherDiffBinaryType Int
deriving (Int -> DiffBinaryType -> ShowS
[DiffBinaryType] -> ShowS
DiffBinaryType -> String
(Int -> DiffBinaryType -> ShowS)
-> (DiffBinaryType -> String)
-> ([DiffBinaryType] -> ShowS)
-> Show DiffBinaryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DiffBinaryType] -> ShowS
$cshowList :: [DiffBinaryType] -> ShowS
show :: DiffBinaryType -> String
$cshow :: DiffBinaryType -> String
showsPrec :: Int -> DiffBinaryType -> ShowS
$cshowsPrec :: Int -> DiffBinaryType -> ShowS
Show, DiffBinaryType -> DiffBinaryType -> Bool
(DiffBinaryType -> DiffBinaryType -> Bool)
-> (DiffBinaryType -> DiffBinaryType -> Bool) -> Eq DiffBinaryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffBinaryType -> DiffBinaryType -> Bool
$c/= :: DiffBinaryType -> DiffBinaryType -> Bool
== :: DiffBinaryType -> DiffBinaryType -> Bool
$c== :: DiffBinaryType -> DiffBinaryType -> Bool
Eq)
instance P.Enum DiffBinaryType where
fromEnum :: DiffBinaryType -> Int
fromEnum DiffBinaryType
DiffBinaryTypeNone = Int
0
fromEnum DiffBinaryType
DiffBinaryTypeLiteral = Int
1
fromEnum DiffBinaryType
DiffBinaryTypeDelta = Int
2
fromEnum (AnotherDiffBinaryType Int
k) = Int
k
toEnum :: Int -> DiffBinaryType
toEnum Int
0 = DiffBinaryType
DiffBinaryTypeNone
toEnum Int
1 = DiffBinaryType
DiffBinaryTypeLiteral
toEnum Int
2 = DiffBinaryType
DiffBinaryTypeDelta
toEnum Int
k = Int -> DiffBinaryType
AnotherDiffBinaryType Int
k
instance P.Ord DiffBinaryType where
compare :: DiffBinaryType -> DiffBinaryType -> Ordering
compare DiffBinaryType
a DiffBinaryType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffBinaryType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffBinaryType
a) (DiffBinaryType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffBinaryType
b)
type instance O.ParentTypes DiffBinaryType = '[]
instance O.HasParentTypes DiffBinaryType
foreign import ccall "ggit_diff_binary_type_get_type" c_ggit_diff_binary_type_get_type ::
IO GType
instance B.Types.TypedObject DiffBinaryType where
glibType :: IO GType
glibType = IO GType
c_ggit_diff_binary_type_get_type
instance B.Types.BoxedEnum DiffBinaryType
data DeltaType =
DeltaTypeUnmodified
| DeltaTypeAdded
| DeltaTypeDeleted
| DeltaTypeModified
| DeltaTypeRenamed
| DeltaTypeCopied
| DeltaTypeIgnored
| DeltaTypeUntracked
| AnotherDeltaType Int
deriving (Int -> DeltaType -> ShowS
[DeltaType] -> ShowS
DeltaType -> String
(Int -> DeltaType -> ShowS)
-> (DeltaType -> String)
-> ([DeltaType] -> ShowS)
-> Show DeltaType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeltaType] -> ShowS
$cshowList :: [DeltaType] -> ShowS
show :: DeltaType -> String
$cshow :: DeltaType -> String
showsPrec :: Int -> DeltaType -> ShowS
$cshowsPrec :: Int -> DeltaType -> ShowS
Show, DeltaType -> DeltaType -> Bool
(DeltaType -> DeltaType -> Bool)
-> (DeltaType -> DeltaType -> Bool) -> Eq DeltaType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeltaType -> DeltaType -> Bool
$c/= :: DeltaType -> DeltaType -> Bool
== :: DeltaType -> DeltaType -> Bool
$c== :: DeltaType -> DeltaType -> Bool
Eq)
instance P.Enum DeltaType where
fromEnum :: DeltaType -> Int
fromEnum DeltaType
DeltaTypeUnmodified = Int
0
fromEnum DeltaType
DeltaTypeAdded = Int
1
fromEnum DeltaType
DeltaTypeDeleted = Int
2
fromEnum DeltaType
DeltaTypeModified = Int
3
fromEnum DeltaType
DeltaTypeRenamed = Int
4
fromEnum DeltaType
DeltaTypeCopied = Int
5
fromEnum DeltaType
DeltaTypeIgnored = Int
6
fromEnum DeltaType
DeltaTypeUntracked = Int
7
fromEnum (AnotherDeltaType Int
k) = Int
k
toEnum :: Int -> DeltaType
toEnum Int
0 = DeltaType
DeltaTypeUnmodified
toEnum Int
1 = DeltaType
DeltaTypeAdded
toEnum Int
2 = DeltaType
DeltaTypeDeleted
toEnum Int
3 = DeltaType
DeltaTypeModified
toEnum Int
4 = DeltaType
DeltaTypeRenamed
toEnum Int
5 = DeltaType
DeltaTypeCopied
toEnum Int
6 = DeltaType
DeltaTypeIgnored
toEnum Int
7 = DeltaType
DeltaTypeUntracked
toEnum Int
k = Int -> DeltaType
AnotherDeltaType Int
k
instance P.Ord DeltaType where
compare :: DeltaType -> DeltaType -> Ordering
compare DeltaType
a DeltaType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeltaType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeltaType
a) (DeltaType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeltaType
b)
type instance O.ParentTypes DeltaType = '[]
instance O.HasParentTypes DeltaType
foreign import ccall "ggit_delta_type_get_type" c_ggit_delta_type_get_type ::
IO GType
instance B.Types.TypedObject DeltaType where
glibType :: IO GType
glibType = IO GType
c_ggit_delta_type_get_type
instance B.Types.BoxedEnum DeltaType
data ConfigLevel =
ConfigLevelProgramdata
| ConfigLevelSystem
| ConfigLevelXdg
| ConfigLevelGlobal
| ConfigLevelLocal
| ConfigLevelApp
| ConfigLevelHighest
| AnotherConfigLevel Int
deriving (Int -> ConfigLevel -> ShowS
[ConfigLevel] -> ShowS
ConfigLevel -> String
(Int -> ConfigLevel -> ShowS)
-> (ConfigLevel -> String)
-> ([ConfigLevel] -> ShowS)
-> Show ConfigLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConfigLevel] -> ShowS
$cshowList :: [ConfigLevel] -> ShowS
show :: ConfigLevel -> String
$cshow :: ConfigLevel -> String
showsPrec :: Int -> ConfigLevel -> ShowS
$cshowsPrec :: Int -> ConfigLevel -> ShowS
Show, ConfigLevel -> ConfigLevel -> Bool
(ConfigLevel -> ConfigLevel -> Bool)
-> (ConfigLevel -> ConfigLevel -> Bool) -> Eq ConfigLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConfigLevel -> ConfigLevel -> Bool
$c/= :: ConfigLevel -> ConfigLevel -> Bool
== :: ConfigLevel -> ConfigLevel -> Bool
$c== :: ConfigLevel -> ConfigLevel -> Bool
Eq)
instance P.Enum ConfigLevel where
fromEnum :: ConfigLevel -> Int
fromEnum ConfigLevel
ConfigLevelProgramdata = Int
1
fromEnum ConfigLevel
ConfigLevelSystem = Int
2
fromEnum ConfigLevel
ConfigLevelXdg = Int
3
fromEnum ConfigLevel
ConfigLevelGlobal = Int
4
fromEnum ConfigLevel
ConfigLevelLocal = Int
5
fromEnum ConfigLevel
ConfigLevelApp = Int
6
fromEnum ConfigLevel
ConfigLevelHighest = Int
-1
fromEnum (AnotherConfigLevel Int
k) = Int
k
toEnum :: Int -> ConfigLevel
toEnum Int
1 = ConfigLevel
ConfigLevelProgramdata
toEnum Int
2 = ConfigLevel
ConfigLevelSystem
toEnum Int
3 = ConfigLevel
ConfigLevelXdg
toEnum Int
4 = ConfigLevel
ConfigLevelGlobal
toEnum Int
5 = ConfigLevel
ConfigLevelLocal
toEnum Int
6 = ConfigLevel
ConfigLevelApp
toEnum Int
-1 = ConfigLevel
ConfigLevelHighest
toEnum Int
k = Int -> ConfigLevel
AnotherConfigLevel Int
k
instance P.Ord ConfigLevel where
compare :: ConfigLevel -> ConfigLevel -> Ordering
compare ConfigLevel
a ConfigLevel
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConfigLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum ConfigLevel
a) (ConfigLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum ConfigLevel
b)
type instance O.ParentTypes ConfigLevel = '[]
instance O.HasParentTypes ConfigLevel
foreign import ccall "ggit_config_level_get_type" c_ggit_config_level_get_type ::
IO GType
instance B.Types.TypedObject ConfigLevel where
glibType :: IO GType
glibType = IO GType
c_ggit_config_level_get_type
instance B.Types.BoxedEnum ConfigLevel
data CloneLocal =
CloneLocalAuto
| CloneLocalLocal
| CloneLocalNoLocal
| CloneLocalNoLinks
| AnotherCloneLocal Int
deriving (Int -> CloneLocal -> ShowS
[CloneLocal] -> ShowS
CloneLocal -> String
(Int -> CloneLocal -> ShowS)
-> (CloneLocal -> String)
-> ([CloneLocal] -> ShowS)
-> Show CloneLocal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CloneLocal] -> ShowS
$cshowList :: [CloneLocal] -> ShowS
show :: CloneLocal -> String
$cshow :: CloneLocal -> String
showsPrec :: Int -> CloneLocal -> ShowS
$cshowsPrec :: Int -> CloneLocal -> ShowS
Show, CloneLocal -> CloneLocal -> Bool
(CloneLocal -> CloneLocal -> Bool)
-> (CloneLocal -> CloneLocal -> Bool) -> Eq CloneLocal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CloneLocal -> CloneLocal -> Bool
$c/= :: CloneLocal -> CloneLocal -> Bool
== :: CloneLocal -> CloneLocal -> Bool
$c== :: CloneLocal -> CloneLocal -> Bool
Eq)
instance P.Enum CloneLocal where
fromEnum :: CloneLocal -> Int
fromEnum CloneLocal
CloneLocalAuto = Int
0
fromEnum CloneLocal
CloneLocalLocal = Int
1
fromEnum CloneLocal
CloneLocalNoLocal = Int
2
fromEnum CloneLocal
CloneLocalNoLinks = Int
3
fromEnum (AnotherCloneLocal Int
k) = Int
k
toEnum :: Int -> CloneLocal
toEnum Int
0 = CloneLocal
CloneLocalAuto
toEnum Int
1 = CloneLocal
CloneLocalLocal
toEnum Int
2 = CloneLocal
CloneLocalNoLocal
toEnum Int
3 = CloneLocal
CloneLocalNoLinks
toEnum Int
k = Int -> CloneLocal
AnotherCloneLocal Int
k
instance P.Ord CloneLocal where
compare :: CloneLocal -> CloneLocal -> Ordering
compare CloneLocal
a CloneLocal
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CloneLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum CloneLocal
a) (CloneLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum CloneLocal
b)
type instance O.ParentTypes CloneLocal = '[]
instance O.HasParentTypes CloneLocal
foreign import ccall "ggit_clone_local_get_type" c_ggit_clone_local_get_type ::
IO GType
instance B.Types.TypedObject CloneLocal where
glibType :: IO GType
glibType = IO GType
c_ggit_clone_local_get_type
instance B.Types.BoxedEnum CloneLocal
data BranchType =
BranchTypeLocal
| BranchTypeRemote
| AnotherBranchType Int
deriving (Int -> BranchType -> ShowS
[BranchType] -> ShowS
BranchType -> String
(Int -> BranchType -> ShowS)
-> (BranchType -> String)
-> ([BranchType] -> ShowS)
-> Show BranchType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BranchType] -> ShowS
$cshowList :: [BranchType] -> ShowS
show :: BranchType -> String
$cshow :: BranchType -> String
showsPrec :: Int -> BranchType -> ShowS
$cshowsPrec :: Int -> BranchType -> ShowS
Show, BranchType -> BranchType -> Bool
(BranchType -> BranchType -> Bool)
-> (BranchType -> BranchType -> Bool) -> Eq BranchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BranchType -> BranchType -> Bool
$c/= :: BranchType -> BranchType -> Bool
== :: BranchType -> BranchType -> Bool
$c== :: BranchType -> BranchType -> Bool
Eq)
instance P.Enum BranchType where
fromEnum :: BranchType -> Int
fromEnum BranchType
BranchTypeLocal = Int
1
fromEnum BranchType
BranchTypeRemote = Int
2
fromEnum (AnotherBranchType Int
k) = Int
k
toEnum :: Int -> BranchType
toEnum Int
1 = BranchType
BranchTypeLocal
toEnum Int
2 = BranchType
BranchTypeRemote
toEnum Int
k = Int -> BranchType
AnotherBranchType Int
k
instance P.Ord BranchType where
compare :: BranchType -> BranchType -> Ordering
compare BranchType
a BranchType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BranchType -> Int
forall a. Enum a => a -> Int
P.fromEnum BranchType
a) (BranchType -> Int
forall a. Enum a => a -> Int
P.fromEnum BranchType
b)
type instance O.ParentTypes BranchType = '[]
instance O.HasParentTypes BranchType
foreign import ccall "ggit_branch_type_get_type" c_ggit_branch_type_get_type ::
IO GType
instance B.Types.TypedObject BranchType where
glibType :: IO GType
glibType = IO GType
c_ggit_branch_type_get_type
instance B.Types.BoxedEnum BranchType