#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
data 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 TreeWalkModePre = 0
fromEnum TreeWalkModePost = 1
fromEnum (AnotherTreeWalkMode k :: Int
k) = Int
k
toEnum :: Int -> TreeWalkMode
toEnum 0 = TreeWalkMode
TreeWalkModePre
toEnum 1 = TreeWalkMode
TreeWalkModePost
toEnum k :: Int
k = Int -> TreeWalkMode
AnotherTreeWalkMode Int
k
instance P.Ord TreeWalkMode where
compare :: TreeWalkMode -> TreeWalkMode -> Ordering
compare a :: TreeWalkMode
a b :: 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)
foreign import ccall "ggit_tree_walk_mode_get_type" c_ggit_tree_walk_mode_get_type ::
IO GType
instance BoxedEnum TreeWalkMode where
boxedEnumType :: TreeWalkMode -> IO GType
boxedEnumType _ = IO GType
c_ggit_tree_walk_mode_get_type
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 SubmoduleUpdateCheckout = 1
fromEnum SubmoduleUpdateRebase = 2
fromEnum SubmoduleUpdateMerge = 3
fromEnum SubmoduleUpdateNone = 4
fromEnum SubmoduleUpdateDefault = 0
fromEnum (AnotherSubmoduleUpdate k :: Int
k) = Int
k
toEnum :: Int -> SubmoduleUpdate
toEnum 1 = SubmoduleUpdate
SubmoduleUpdateCheckout
toEnum 2 = SubmoduleUpdate
SubmoduleUpdateRebase
toEnum 3 = SubmoduleUpdate
SubmoduleUpdateMerge
toEnum 4 = SubmoduleUpdate
SubmoduleUpdateNone
toEnum 0 = SubmoduleUpdate
SubmoduleUpdateDefault
toEnum k :: Int
k = Int -> SubmoduleUpdate
AnotherSubmoduleUpdate Int
k
instance P.Ord SubmoduleUpdate where
compare :: SubmoduleUpdate -> SubmoduleUpdate -> Ordering
compare a :: SubmoduleUpdate
a b :: 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)
foreign import ccall "ggit_submodule_update_get_type" c_ggit_submodule_update_get_type ::
IO GType
instance BoxedEnum SubmoduleUpdate where
boxedEnumType :: SubmoduleUpdate -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_update_get_type
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 SubmoduleRecurseNo = 0
fromEnum SubmoduleRecurseYes = 1
fromEnum SubmoduleRecurseOndemand = 2
fromEnum (AnotherSubmoduleRecurse k :: Int
k) = Int
k
toEnum :: Int -> SubmoduleRecurse
toEnum 0 = SubmoduleRecurse
SubmoduleRecurseNo
toEnum 1 = SubmoduleRecurse
SubmoduleRecurseYes
toEnum 2 = SubmoduleRecurse
SubmoduleRecurseOndemand
toEnum k :: Int
k = Int -> SubmoduleRecurse
AnotherSubmoduleRecurse Int
k
instance P.Ord SubmoduleRecurse where
compare :: SubmoduleRecurse -> SubmoduleRecurse -> Ordering
compare a :: SubmoduleRecurse
a b :: 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)
foreign import ccall "ggit_submodule_recurse_get_type" c_ggit_submodule_recurse_get_type ::
IO GType
instance BoxedEnum SubmoduleRecurse where
boxedEnumType :: SubmoduleRecurse -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_recurse_get_type
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 SubmoduleIgnoreUnspecified = -1
fromEnum SubmoduleIgnoreNone = 1
fromEnum SubmoduleIgnoreUntracked = 2
fromEnum SubmoduleIgnoreDirty = 3
fromEnum SubmoduleIgnoreAll = 4
fromEnum (AnotherSubmoduleIgnore k :: Int
k) = Int
k
toEnum :: Int -> SubmoduleIgnore
toEnum -1 = SubmoduleIgnore
SubmoduleIgnoreUnspecified
toEnum 1 = SubmoduleIgnore
SubmoduleIgnoreNone
toEnum 2 = SubmoduleIgnore
SubmoduleIgnoreUntracked
toEnum 3 = SubmoduleIgnore
SubmoduleIgnoreDirty
toEnum 4 = SubmoduleIgnore
SubmoduleIgnoreAll
toEnum k :: Int
k = Int -> SubmoduleIgnore
AnotherSubmoduleIgnore Int
k
instance P.Ord SubmoduleIgnore where
compare :: SubmoduleIgnore -> SubmoduleIgnore -> Ordering
compare a :: SubmoduleIgnore
a b :: 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)
foreign import ccall "ggit_submodule_ignore_get_type" c_ggit_submodule_ignore_get_type ::
IO GType
instance BoxedEnum SubmoduleIgnore where
boxedEnumType :: SubmoduleIgnore -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_ignore_get_type
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 StatusShowIndexAndWorkdir = 0
fromEnum StatusShowIndexOnly = 1
fromEnum StatusShowWorkdirOnly = 2
fromEnum (AnotherStatusShow k :: Int
k) = Int
k
toEnum :: Int -> StatusShow
toEnum 0 = StatusShow
StatusShowIndexAndWorkdir
toEnum 1 = StatusShow
StatusShowIndexOnly
toEnum 2 = StatusShow
StatusShowWorkdirOnly
toEnum k :: Int
k = Int -> StatusShow
AnotherStatusShow Int
k
instance P.Ord StatusShow where
compare :: StatusShow -> StatusShow -> Ordering
compare a :: StatusShow
a b :: 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)
foreign import ccall "ggit_status_show_get_type" c_ggit_status_show_get_type ::
IO GType
instance BoxedEnum StatusShow where
boxedEnumType :: StatusShow -> IO GType
boxedEnumType _ = IO GType
c_ggit_status_show_get_type
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 ResetTypeSoft = 1
fromEnum ResetTypeMixed = 2
fromEnum ResetTypeHard = 3
fromEnum (AnotherResetType k :: Int
k) = Int
k
toEnum :: Int -> ResetType
toEnum 1 = ResetType
ResetTypeSoft
toEnum 2 = ResetType
ResetTypeMixed
toEnum 3 = ResetType
ResetTypeHard
toEnum k :: Int
k = Int -> ResetType
AnotherResetType Int
k
instance P.Ord ResetType where
compare :: ResetType -> ResetType -> Ordering
compare a :: ResetType
a b :: 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)
foreign import ccall "ggit_reset_type_get_type" c_ggit_reset_type_get_type ::
IO GType
instance BoxedEnum ResetType where
boxedEnumType :: ResetType -> IO GType
boxedEnumType _ = IO GType
c_ggit_reset_type_get_type
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 RemoteDownloadTagsTypeUnspecified = 0
fromEnum RemoteDownloadTagsTypeAuto = 1
fromEnum RemoteDownloadTagsTypeNone = 2
fromEnum RemoteDownloadTagsTypeAll = 3
fromEnum (AnotherRemoteDownloadTagsType k :: Int
k) = Int
k
toEnum :: Int -> RemoteDownloadTagsType
toEnum 0 = RemoteDownloadTagsType
RemoteDownloadTagsTypeUnspecified
toEnum 1 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAuto
toEnum 2 = RemoteDownloadTagsType
RemoteDownloadTagsTypeNone
toEnum 3 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAll
toEnum k :: Int
k = Int -> RemoteDownloadTagsType
AnotherRemoteDownloadTagsType Int
k
instance P.Ord RemoteDownloadTagsType where
compare :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Ordering
compare a :: RemoteDownloadTagsType
a b :: 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)
foreign import ccall "ggit_remote_download_tags_type_get_type" c_ggit_remote_download_tags_type_get_type ::
IO GType
instance BoxedEnum RemoteDownloadTagsType where
boxedEnumType :: RemoteDownloadTagsType -> IO GType
boxedEnumType _ = IO GType
c_ggit_remote_download_tags_type_get_type
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 RemoteCompletionTypeDownload = 0
fromEnum RemoteCompletionTypeIndexing = 1
fromEnum RemoteCompletionTypeError = 2
fromEnum (AnotherRemoteCompletionType k :: Int
k) = Int
k
toEnum :: Int -> RemoteCompletionType
toEnum 0 = RemoteCompletionType
RemoteCompletionTypeDownload
toEnum 1 = RemoteCompletionType
RemoteCompletionTypeIndexing
toEnum 2 = RemoteCompletionType
RemoteCompletionTypeError
toEnum k :: Int
k = Int -> RemoteCompletionType
AnotherRemoteCompletionType Int
k
instance P.Ord RemoteCompletionType where
compare :: RemoteCompletionType -> RemoteCompletionType -> Ordering
compare a :: RemoteCompletionType
a b :: 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)
foreign import ccall "ggit_remote_completion_type_get_type" c_ggit_remote_completion_type_get_type ::
IO GType
instance BoxedEnum RemoteCompletionType where
boxedEnumType :: RemoteCompletionType -> IO GType
boxedEnumType _ = IO GType
c_ggit_remote_completion_type_get_type
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 RefTypeInvalid = 0
fromEnum RefTypeOid = 1
fromEnum RefTypeSymbolic = 2
fromEnum RefTypeListall = 3
fromEnum (AnotherRefType k :: Int
k) = Int
k
toEnum :: Int -> RefType
toEnum 0 = RefType
RefTypeInvalid
toEnum 1 = RefType
RefTypeOid
toEnum 2 = RefType
RefTypeSymbolic
toEnum 3 = RefType
RefTypeListall
toEnum k :: Int
k = Int -> RefType
AnotherRefType Int
k
instance P.Ord RefType where
compare :: RefType -> RefType -> Ordering
compare a :: RefType
a b :: 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)
foreign import ccall "ggit_ref_type_get_type" c_ggit_ref_type_get_type ::
IO GType
instance BoxedEnum RefType where
boxedEnumType :: RefType -> IO GType
boxedEnumType _ = IO GType
c_ggit_ref_type_get_type
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 RebaseOperationTypePick = 0
fromEnum RebaseOperationTypeReword = 1
fromEnum RebaseOperationTypeEdit = 2
fromEnum RebaseOperationTypeSquash = 3
fromEnum RebaseOperationTypeFixup = 4
fromEnum RebaseOperationTypeExec = 5
fromEnum (AnotherRebaseOperationType k :: Int
k) = Int
k
toEnum :: Int -> RebaseOperationType
toEnum 0 = RebaseOperationType
RebaseOperationTypePick
toEnum 1 = RebaseOperationType
RebaseOperationTypeReword
toEnum 2 = RebaseOperationType
RebaseOperationTypeEdit
toEnum 3 = RebaseOperationType
RebaseOperationTypeSquash
toEnum 4 = RebaseOperationType
RebaseOperationTypeFixup
toEnum 5 = RebaseOperationType
RebaseOperationTypeExec
toEnum k :: Int
k = Int -> RebaseOperationType
AnotherRebaseOperationType Int
k
instance P.Ord RebaseOperationType where
compare :: RebaseOperationType -> RebaseOperationType -> Ordering
compare a :: RebaseOperationType
a b :: 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)
foreign import ccall "ggit_rebase_operation_type_get_type" c_ggit_rebase_operation_type_get_type ::
IO GType
instance BoxedEnum RebaseOperationType where
boxedEnumType :: RebaseOperationType -> IO GType
boxedEnumType _ = IO GType
c_ggit_rebase_operation_type_get_type
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 ProxyTypeNone = 0
fromEnum ProxyTypeAuto = 1
fromEnum ProxyTypeSpecified = 2
fromEnum (AnotherProxyType k :: Int
k) = Int
k
toEnum :: Int -> ProxyType
toEnum 0 = ProxyType
ProxyTypeNone
toEnum 1 = ProxyType
ProxyTypeAuto
toEnum 2 = ProxyType
ProxyTypeSpecified
toEnum k :: Int
k = Int -> ProxyType
AnotherProxyType Int
k
instance P.Ord ProxyType where
compare :: ProxyType -> ProxyType -> Ordering
compare a :: ProxyType
a b :: 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)
foreign import ccall "ggit_proxy_type_get_type" c_ggit_proxy_type_get_type ::
IO GType
instance BoxedEnum ProxyType where
boxedEnumType :: ProxyType -> IO GType
boxedEnumType _ = IO GType
c_ggit_proxy_type_get_type
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 PackbuilderStageAddingObjects = 0
fromEnum PackbuilderStageDeltafication = 1
fromEnum (AnotherPackbuilderStage k :: Int
k) = Int
k
toEnum :: Int -> PackbuilderStage
toEnum 0 = PackbuilderStage
PackbuilderStageAddingObjects
toEnum 1 = PackbuilderStage
PackbuilderStageDeltafication
toEnum k :: Int
k = Int -> PackbuilderStage
AnotherPackbuilderStage Int
k
instance P.Ord PackbuilderStage where
compare :: PackbuilderStage -> PackbuilderStage -> Ordering
compare a :: PackbuilderStage
a b :: 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)
foreign import ccall "ggit_packbuilder_stage_get_type" c_ggit_packbuilder_stage_get_type ::
IO GType
instance BoxedEnum PackbuilderStage where
boxedEnumType :: PackbuilderStage -> IO GType
boxedEnumType _ = IO GType
c_ggit_packbuilder_stage_get_type
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 MergeFileFavorNormal = 0
fromEnum MergeFileFavorOurs = 1
fromEnum MergeFileFavorTheirs = 2
fromEnum MergeFileFavorUnion = 3
fromEnum (AnotherMergeFileFavor k :: Int
k) = Int
k
toEnum :: Int -> MergeFileFavor
toEnum 0 = MergeFileFavor
MergeFileFavorNormal
toEnum 1 = MergeFileFavor
MergeFileFavorOurs
toEnum 2 = MergeFileFavor
MergeFileFavorTheirs
toEnum 3 = MergeFileFavor
MergeFileFavorUnion
toEnum k :: Int
k = Int -> MergeFileFavor
AnotherMergeFileFavor Int
k
instance P.Ord MergeFileFavor where
compare :: MergeFileFavor -> MergeFileFavor -> Ordering
compare a :: MergeFileFavor
a b :: 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)
foreign import ccall "ggit_merge_file_favor_get_type" c_ggit_merge_file_favor_get_type ::
IO GType
instance BoxedEnum MergeFileFavor where
boxedEnumType :: MergeFileFavor -> IO GType
boxedEnumType _ = IO GType
c_ggit_merge_file_favor_get_type
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 FileModeUnreadable = 0
fromEnum FileModeTree = 16384
fromEnum FileModeBlob = 33188
fromEnum FileModeBlobExecutable = 33261
fromEnum FileModeLink = 40960
fromEnum FileModeCommit = 57344
fromEnum (AnotherFileMode k :: Int
k) = Int
k
toEnum :: Int -> FileMode
toEnum 0 = FileMode
FileModeUnreadable
toEnum 16384 = FileMode
FileModeTree
toEnum 33188 = FileMode
FileModeBlob
toEnum 33261 = FileMode
FileModeBlobExecutable
toEnum 40960 = FileMode
FileModeLink
toEnum 57344 = FileMode
FileModeCommit
toEnum k :: Int
k = Int -> FileMode
AnotherFileMode Int
k
instance P.Ord FileMode where
compare :: FileMode -> FileMode -> Ordering
compare a :: FileMode
a b :: 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)
foreign import ccall "ggit_file_mode_get_type" c_ggit_file_mode_get_type ::
IO GType
instance BoxedEnum FileMode where
boxedEnumType :: FileMode -> IO GType
boxedEnumType _ = IO GType
c_ggit_file_mode_get_type
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 ErrorGitError = -1
fromEnum ErrorNotfound = -3
fromEnum ErrorExists = -4
fromEnum ErrorAmbiguous = -5
fromEnum ErrorBufs = -6
fromEnum ErrorPassthrough = -30
fromEnum ErrorIterover = -31
fromEnum (AnotherError k :: Int
k) = Int
k
toEnum :: Int -> Error
toEnum -1 = Error
ErrorGitError
toEnum -3 = Error
ErrorNotfound
toEnum -4 = Error
ErrorExists
toEnum -5 = Error
ErrorAmbiguous
toEnum -6 = Error
ErrorBufs
toEnum -30 = Error
ErrorPassthrough
toEnum -31 = Error
ErrorIterover
toEnum k :: Int
k = Int -> Error
AnotherError Int
k
instance P.Ord Error where
compare :: Error -> Error -> Ordering
compare a :: Error
a b :: 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 _ = "ggit-error"
catchError ::
IO a ->
(Error -> GErrorMessage -> IO a) ->
IO a
catchError :: 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 :: (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
foreign import ccall "ggit_error_get_type" c_ggit_error_get_type ::
IO GType
instance BoxedEnum Error where
boxedEnumType :: Error -> IO GType
boxedEnumType _ = IO GType
c_ggit_error_get_type
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 DirectionFetch = 0
fromEnum DirectionPush = 1
fromEnum (AnotherDirection k :: Int
k) = Int
k
toEnum :: Int -> Direction
toEnum 0 = Direction
DirectionFetch
toEnum 1 = Direction
DirectionPush
toEnum k :: Int
k = Int -> Direction
AnotherDirection Int
k
instance P.Ord Direction where
compare :: Direction -> Direction -> Ordering
compare a :: Direction
a b :: 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)
foreign import ccall "ggit_direction_get_type" c_ggit_direction_get_type ::
IO GType
instance BoxedEnum Direction where
boxedEnumType :: Direction -> IO GType
boxedEnumType _ = IO GType
c_ggit_direction_get_type
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 DiffLineTypeContext = 32
fromEnum DiffLineTypeAddition = 43
fromEnum DiffLineTypeDeletion = 45
fromEnum DiffLineTypeContextEofnl = 61
fromEnum DiffLineTypeAddEofnl = 62
fromEnum DiffLineTypeDelEofnl = 60
fromEnum DiffLineTypeFileHdr = 70
fromEnum DiffLineTypeHunkHdr = 72
fromEnum DiffLineTypeBinary = 66
fromEnum (AnotherDiffLineType k :: Int
k) = Int
k
toEnum :: Int -> DiffLineType
toEnum 32 = DiffLineType
DiffLineTypeContext
toEnum 43 = DiffLineType
DiffLineTypeAddition
toEnum 45 = DiffLineType
DiffLineTypeDeletion
toEnum 61 = DiffLineType
DiffLineTypeContextEofnl
toEnum 62 = DiffLineType
DiffLineTypeAddEofnl
toEnum 60 = DiffLineType
DiffLineTypeDelEofnl
toEnum 70 = DiffLineType
DiffLineTypeFileHdr
toEnum 72 = DiffLineType
DiffLineTypeHunkHdr
toEnum 66 = DiffLineType
DiffLineTypeBinary
toEnum k :: Int
k = Int -> DiffLineType
AnotherDiffLineType Int
k
instance P.Ord DiffLineType where
compare :: DiffLineType -> DiffLineType -> Ordering
compare a :: DiffLineType
a b :: 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)
foreign import ccall "ggit_diff_line_type_get_type" c_ggit_diff_line_type_get_type ::
IO GType
instance BoxedEnum DiffLineType where
boxedEnumType :: DiffLineType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_line_type_get_type
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 DiffFormatTypePatch = 1
fromEnum DiffFormatTypePatchHeader = 2
fromEnum DiffFormatTypeRaw = 3
fromEnum DiffFormatTypeNameOnly = 4
fromEnum DiffFormatTypeNameStatus = 5
fromEnum (AnotherDiffFormatType k :: Int
k) = Int
k
toEnum :: Int -> DiffFormatType
toEnum 1 = DiffFormatType
DiffFormatTypePatch
toEnum 2 = DiffFormatType
DiffFormatTypePatchHeader
toEnum 3 = DiffFormatType
DiffFormatTypeRaw
toEnum 4 = DiffFormatType
DiffFormatTypeNameOnly
toEnum 5 = DiffFormatType
DiffFormatTypeNameStatus
toEnum k :: Int
k = Int -> DiffFormatType
AnotherDiffFormatType Int
k
instance P.Ord DiffFormatType where
compare :: DiffFormatType -> DiffFormatType -> Ordering
compare a :: DiffFormatType
a b :: 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)
foreign import ccall "ggit_diff_format_type_get_type" c_ggit_diff_format_type_get_type ::
IO GType
instance BoxedEnum DiffFormatType where
boxedEnumType :: DiffFormatType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_format_type_get_type
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 DiffBinaryTypeNone = 0
fromEnum DiffBinaryTypeLiteral = 1
fromEnum DiffBinaryTypeDelta = 2
fromEnum (AnotherDiffBinaryType k :: Int
k) = Int
k
toEnum :: Int -> DiffBinaryType
toEnum 0 = DiffBinaryType
DiffBinaryTypeNone
toEnum 1 = DiffBinaryType
DiffBinaryTypeLiteral
toEnum 2 = DiffBinaryType
DiffBinaryTypeDelta
toEnum k :: Int
k = Int -> DiffBinaryType
AnotherDiffBinaryType Int
k
instance P.Ord DiffBinaryType where
compare :: DiffBinaryType -> DiffBinaryType -> Ordering
compare a :: DiffBinaryType
a b :: 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)
foreign import ccall "ggit_diff_binary_type_get_type" c_ggit_diff_binary_type_get_type ::
IO GType
instance BoxedEnum DiffBinaryType where
boxedEnumType :: DiffBinaryType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_binary_type_get_type
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 DeltaTypeUnmodified = 0
fromEnum DeltaTypeAdded = 1
fromEnum DeltaTypeDeleted = 2
fromEnum DeltaTypeModified = 3
fromEnum DeltaTypeRenamed = 4
fromEnum DeltaTypeCopied = 5
fromEnum DeltaTypeIgnored = 6
fromEnum DeltaTypeUntracked = 7
fromEnum (AnotherDeltaType k :: Int
k) = Int
k
toEnum :: Int -> DeltaType
toEnum 0 = DeltaType
DeltaTypeUnmodified
toEnum 1 = DeltaType
DeltaTypeAdded
toEnum 2 = DeltaType
DeltaTypeDeleted
toEnum 3 = DeltaType
DeltaTypeModified
toEnum 4 = DeltaType
DeltaTypeRenamed
toEnum 5 = DeltaType
DeltaTypeCopied
toEnum 6 = DeltaType
DeltaTypeIgnored
toEnum 7 = DeltaType
DeltaTypeUntracked
toEnum k :: Int
k = Int -> DeltaType
AnotherDeltaType Int
k
instance P.Ord DeltaType where
compare :: DeltaType -> DeltaType -> Ordering
compare a :: DeltaType
a b :: 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)
foreign import ccall "ggit_delta_type_get_type" c_ggit_delta_type_get_type ::
IO GType
instance BoxedEnum DeltaType where
boxedEnumType :: DeltaType -> IO GType
boxedEnumType _ = IO GType
c_ggit_delta_type_get_type
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 ConfigLevelProgramdata = 1
fromEnum ConfigLevelSystem = 2
fromEnum ConfigLevelXdg = 3
fromEnum ConfigLevelGlobal = 4
fromEnum ConfigLevelLocal = 5
fromEnum ConfigLevelApp = 6
fromEnum ConfigLevelHighest = -1
fromEnum (AnotherConfigLevel k :: Int
k) = Int
k
toEnum :: Int -> ConfigLevel
toEnum 1 = ConfigLevel
ConfigLevelProgramdata
toEnum 2 = ConfigLevel
ConfigLevelSystem
toEnum 3 = ConfigLevel
ConfigLevelXdg
toEnum 4 = ConfigLevel
ConfigLevelGlobal
toEnum 5 = ConfigLevel
ConfigLevelLocal
toEnum 6 = ConfigLevel
ConfigLevelApp
toEnum -1 = ConfigLevel
ConfigLevelHighest
toEnum k :: Int
k = Int -> ConfigLevel
AnotherConfigLevel Int
k
instance P.Ord ConfigLevel where
compare :: ConfigLevel -> ConfigLevel -> Ordering
compare a :: ConfigLevel
a b :: 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)
foreign import ccall "ggit_config_level_get_type" c_ggit_config_level_get_type ::
IO GType
instance BoxedEnum ConfigLevel where
boxedEnumType :: ConfigLevel -> IO GType
boxedEnumType _ = IO GType
c_ggit_config_level_get_type
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 CloneLocalAuto = 0
fromEnum CloneLocalLocal = 1
fromEnum CloneLocalNoLocal = 2
fromEnum CloneLocalNoLinks = 3
fromEnum (AnotherCloneLocal k :: Int
k) = Int
k
toEnum :: Int -> CloneLocal
toEnum 0 = CloneLocal
CloneLocalAuto
toEnum 1 = CloneLocal
CloneLocalLocal
toEnum 2 = CloneLocal
CloneLocalNoLocal
toEnum 3 = CloneLocal
CloneLocalNoLinks
toEnum k :: Int
k = Int -> CloneLocal
AnotherCloneLocal Int
k
instance P.Ord CloneLocal where
compare :: CloneLocal -> CloneLocal -> Ordering
compare a :: CloneLocal
a b :: 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)
foreign import ccall "ggit_clone_local_get_type" c_ggit_clone_local_get_type ::
IO GType
instance BoxedEnum CloneLocal where
boxedEnumType :: CloneLocal -> IO GType
boxedEnumType _ = IO GType
c_ggit_clone_local_get_type
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 BranchTypeLocal = 1
fromEnum BranchTypeRemote = 2
fromEnum (AnotherBranchType k :: Int
k) = Int
k
toEnum :: Int -> BranchType
toEnum 1 = BranchType
BranchTypeLocal
toEnum 2 = BranchType
BranchTypeRemote
toEnum k :: Int
k = Int -> BranchType
AnotherBranchType Int
k
instance P.Ord BranchType where
compare :: BranchType -> BranchType -> Ordering
compare a :: BranchType
a b :: 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)
foreign import ccall "ggit_branch_type_get_type" c_ggit_branch_type_get_type ::
IO GType
instance BoxedEnum BranchType where
boxedEnumType :: BranchType -> IO GType
boxedEnumType _ = IO GType
c_ggit_branch_type_get_type