#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.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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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 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)
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