#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Flags
(
Cacheability(..) ,
Expectation(..) ,
MessageFlags(..) ,
ServerListenOptions(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data ServerListenOptions =
ServerListenOptionsHttps
| ServerListenOptionsIpv4Only
| ServerListenOptionsIpv6Only
| AnotherServerListenOptions Int
deriving (Int -> ServerListenOptions -> ShowS
[ServerListenOptions] -> ShowS
ServerListenOptions -> String
(Int -> ServerListenOptions -> ShowS)
-> (ServerListenOptions -> String)
-> ([ServerListenOptions] -> ShowS)
-> Show ServerListenOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServerListenOptions] -> ShowS
$cshowList :: [ServerListenOptions] -> ShowS
show :: ServerListenOptions -> String
$cshow :: ServerListenOptions -> String
showsPrec :: Int -> ServerListenOptions -> ShowS
$cshowsPrec :: Int -> ServerListenOptions -> ShowS
Show, ServerListenOptions -> ServerListenOptions -> Bool
(ServerListenOptions -> ServerListenOptions -> Bool)
-> (ServerListenOptions -> ServerListenOptions -> Bool)
-> Eq ServerListenOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerListenOptions -> ServerListenOptions -> Bool
$c/= :: ServerListenOptions -> ServerListenOptions -> Bool
== :: ServerListenOptions -> ServerListenOptions -> Bool
$c== :: ServerListenOptions -> ServerListenOptions -> Bool
Eq)
instance P.Enum ServerListenOptions where
fromEnum :: ServerListenOptions -> Int
fromEnum ServerListenOptions
ServerListenOptionsHttps = Int
1
fromEnum ServerListenOptions
ServerListenOptionsIpv4Only = Int
2
fromEnum ServerListenOptions
ServerListenOptionsIpv6Only = Int
4
fromEnum (AnotherServerListenOptions Int
k) = Int
k
toEnum :: Int -> ServerListenOptions
toEnum Int
1 = ServerListenOptions
ServerListenOptionsHttps
toEnum Int
2 = ServerListenOptions
ServerListenOptionsIpv4Only
toEnum Int
4 = ServerListenOptions
ServerListenOptionsIpv6Only
toEnum Int
k = Int -> ServerListenOptions
AnotherServerListenOptions Int
k
instance P.Ord ServerListenOptions where
compare :: ServerListenOptions -> ServerListenOptions -> Ordering
compare ServerListenOptions
a ServerListenOptions
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ServerListenOptions -> Int
forall a. Enum a => a -> Int
P.fromEnum ServerListenOptions
a) (ServerListenOptions -> Int
forall a. Enum a => a -> Int
P.fromEnum ServerListenOptions
b)
type instance O.ParentTypes ServerListenOptions = '[]
instance O.HasParentTypes ServerListenOptions
foreign import ccall "soup_server_listen_options_get_type" c_soup_server_listen_options_get_type ::
IO GType
instance B.Types.TypedObject ServerListenOptions where
glibType :: IO GType
glibType = IO GType
c_soup_server_listen_options_get_type
instance B.Types.BoxedFlags ServerListenOptions
instance IsGFlag ServerListenOptions
data MessageFlags =
MessageFlagsNoRedirect
| MessageFlagsCanRebuild
| MessageFlagsOverwriteChunks
| MessageFlagsContentDecoded
| MessageFlagsCertificateTrusted
| MessageFlagsNewConnection
| MessageFlagsIdempotent
| MessageFlagsIgnoreConnectionLimits
| MessageFlagsDoNotUseAuthCache
| AnotherMessageFlags Int
deriving (Int -> MessageFlags -> ShowS
[MessageFlags] -> ShowS
MessageFlags -> String
(Int -> MessageFlags -> ShowS)
-> (MessageFlags -> String)
-> ([MessageFlags] -> ShowS)
-> Show MessageFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageFlags] -> ShowS
$cshowList :: [MessageFlags] -> ShowS
show :: MessageFlags -> String
$cshow :: MessageFlags -> String
showsPrec :: Int -> MessageFlags -> ShowS
$cshowsPrec :: Int -> MessageFlags -> ShowS
Show, MessageFlags -> MessageFlags -> Bool
(MessageFlags -> MessageFlags -> Bool)
-> (MessageFlags -> MessageFlags -> Bool) -> Eq MessageFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageFlags -> MessageFlags -> Bool
$c/= :: MessageFlags -> MessageFlags -> Bool
== :: MessageFlags -> MessageFlags -> Bool
$c== :: MessageFlags -> MessageFlags -> Bool
Eq)
instance P.Enum MessageFlags where
fromEnum :: MessageFlags -> Int
fromEnum MessageFlags
MessageFlagsNoRedirect = Int
2
fromEnum MessageFlags
MessageFlagsCanRebuild = Int
4
fromEnum MessageFlags
MessageFlagsOverwriteChunks = Int
8
fromEnum MessageFlags
MessageFlagsContentDecoded = Int
16
fromEnum MessageFlags
MessageFlagsCertificateTrusted = Int
32
fromEnum MessageFlags
MessageFlagsNewConnection = Int
64
fromEnum MessageFlags
MessageFlagsIdempotent = Int
128
fromEnum MessageFlags
MessageFlagsIgnoreConnectionLimits = Int
256
fromEnum MessageFlags
MessageFlagsDoNotUseAuthCache = Int
512
fromEnum (AnotherMessageFlags Int
k) = Int
k
toEnum :: Int -> MessageFlags
toEnum Int
2 = MessageFlags
MessageFlagsNoRedirect
toEnum Int
4 = MessageFlags
MessageFlagsCanRebuild
toEnum Int
8 = MessageFlags
MessageFlagsOverwriteChunks
toEnum Int
16 = MessageFlags
MessageFlagsContentDecoded
toEnum Int
32 = MessageFlags
MessageFlagsCertificateTrusted
toEnum Int
64 = MessageFlags
MessageFlagsNewConnection
toEnum Int
128 = MessageFlags
MessageFlagsIdempotent
toEnum Int
256 = MessageFlags
MessageFlagsIgnoreConnectionLimits
toEnum Int
512 = MessageFlags
MessageFlagsDoNotUseAuthCache
toEnum Int
k = Int -> MessageFlags
AnotherMessageFlags Int
k
instance P.Ord MessageFlags where
compare :: MessageFlags -> MessageFlags -> Ordering
compare MessageFlags
a MessageFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageFlags
a) (MessageFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageFlags
b)
type instance O.ParentTypes MessageFlags = '[]
instance O.HasParentTypes MessageFlags
foreign import ccall "soup_message_flags_get_type" c_soup_message_flags_get_type ::
IO GType
instance B.Types.TypedObject MessageFlags where
glibType :: IO GType
glibType = IO GType
c_soup_message_flags_get_type
instance B.Types.BoxedFlags MessageFlags
instance IsGFlag MessageFlags
data Expectation =
ExpectationUnrecognized
| ExpectationContinue
| AnotherExpectation Int
deriving (Int -> Expectation -> ShowS
[Expectation] -> ShowS
Expectation -> String
(Int -> Expectation -> ShowS)
-> (Expectation -> String)
-> ([Expectation] -> ShowS)
-> Show Expectation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expectation] -> ShowS
$cshowList :: [Expectation] -> ShowS
show :: Expectation -> String
$cshow :: Expectation -> String
showsPrec :: Int -> Expectation -> ShowS
$cshowsPrec :: Int -> Expectation -> ShowS
Show, Expectation -> Expectation -> Bool
(Expectation -> Expectation -> Bool)
-> (Expectation -> Expectation -> Bool) -> Eq Expectation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expectation -> Expectation -> Bool
$c/= :: Expectation -> Expectation -> Bool
== :: Expectation -> Expectation -> Bool
$c== :: Expectation -> Expectation -> Bool
Eq)
instance P.Enum Expectation where
fromEnum :: Expectation -> Int
fromEnum Expectation
ExpectationUnrecognized = Int
1
fromEnum Expectation
ExpectationContinue = Int
2
fromEnum (AnotherExpectation Int
k) = Int
k
toEnum :: Int -> Expectation
toEnum Int
1 = Expectation
ExpectationUnrecognized
toEnum Int
2 = Expectation
ExpectationContinue
toEnum Int
k = Int -> Expectation
AnotherExpectation Int
k
instance P.Ord Expectation where
compare :: Expectation -> Expectation -> Ordering
compare Expectation
a Expectation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Expectation -> Int
forall a. Enum a => a -> Int
P.fromEnum Expectation
a) (Expectation -> Int
forall a. Enum a => a -> Int
P.fromEnum Expectation
b)
type instance O.ParentTypes Expectation = '[]
instance O.HasParentTypes Expectation
foreign import ccall "soup_expectation_get_type" c_soup_expectation_get_type ::
IO GType
instance B.Types.TypedObject Expectation where
glibType :: IO GType
glibType = IO GType
c_soup_expectation_get_type
instance B.Types.BoxedFlags Expectation
instance IsGFlag Expectation
data Cacheability =
CacheabilityCacheable
| CacheabilityUncacheable
| CacheabilityInvalidates
| CacheabilityValidates
| AnotherCacheability Int
deriving (Int -> Cacheability -> ShowS
[Cacheability] -> ShowS
Cacheability -> String
(Int -> Cacheability -> ShowS)
-> (Cacheability -> String)
-> ([Cacheability] -> ShowS)
-> Show Cacheability
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cacheability] -> ShowS
$cshowList :: [Cacheability] -> ShowS
show :: Cacheability -> String
$cshow :: Cacheability -> String
showsPrec :: Int -> Cacheability -> ShowS
$cshowsPrec :: Int -> Cacheability -> ShowS
Show, Cacheability -> Cacheability -> Bool
(Cacheability -> Cacheability -> Bool)
-> (Cacheability -> Cacheability -> Bool) -> Eq Cacheability
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cacheability -> Cacheability -> Bool
$c/= :: Cacheability -> Cacheability -> Bool
== :: Cacheability -> Cacheability -> Bool
$c== :: Cacheability -> Cacheability -> Bool
Eq)
instance P.Enum Cacheability where
fromEnum :: Cacheability -> Int
fromEnum Cacheability
CacheabilityCacheable = Int
1
fromEnum Cacheability
CacheabilityUncacheable = Int
2
fromEnum Cacheability
CacheabilityInvalidates = Int
4
fromEnum Cacheability
CacheabilityValidates = Int
8
fromEnum (AnotherCacheability Int
k) = Int
k
toEnum :: Int -> Cacheability
toEnum Int
1 = Cacheability
CacheabilityCacheable
toEnum Int
2 = Cacheability
CacheabilityUncacheable
toEnum Int
4 = Cacheability
CacheabilityInvalidates
toEnum Int
8 = Cacheability
CacheabilityValidates
toEnum Int
k = Int -> Cacheability
AnotherCacheability Int
k
instance P.Ord Cacheability where
compare :: Cacheability -> Cacheability -> Ordering
compare Cacheability
a Cacheability
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Cacheability -> Int
forall a. Enum a => a -> Int
P.fromEnum Cacheability
a) (Cacheability -> Int
forall a. Enum a => a -> Int
P.fromEnum Cacheability
b)
type instance O.ParentTypes Cacheability = '[]
instance O.HasParentTypes Cacheability
foreign import ccall "soup_cacheability_get_type" c_soup_cacheability_get_type ::
IO GType
instance B.Types.TypedObject Cacheability where
glibType :: IO GType
glibType = IO GType
c_soup_cacheability_get_type
instance B.Types.BoxedFlags Cacheability
instance IsGFlag Cacheability