-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Flags
    ( 

 -- * Flags


-- ** Cacheability #flag:Cacheability#

    Cacheability(..)                        ,


-- ** Expectation #flag:Expectation#

    Expectation(..)                         ,


-- ** MessageFlags #flag:MessageFlags#

    MessageFlags(..)                        ,


-- ** ServerListenOptions #flag:ServerListenOptions#

    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


-- Flags ServerListenOptions
-- | Options to pass to 'GI.Soup.Objects.Server.serverListen', etc.
-- 
-- 'GI.Soup.Flags.ServerListenOptionsIpv4Only' and 'GI.Soup.Flags.ServerListenOptionsIpv6Only'
-- only make sense with 'GI.Soup.Objects.Server.serverListenAll' and
-- 'GI.Soup.Objects.Server.serverListenLocal', not plain 'GI.Soup.Objects.Server.serverListen' (which
-- simply listens on whatever kind of socket you give it). And you
-- cannot specify both of them in a single call.
-- 
-- /Since: 2.48/
data ServerListenOptions = 
      ServerListenOptionsHttps
    -- ^ Listen for https connections rather
    --   than plain http.
    | ServerListenOptionsIpv4Only
    -- ^ Only listen on IPv4 interfaces.
    | ServerListenOptionsIpv6Only
    -- ^ Only listen on IPv6 interfaces.
    | AnotherServerListenOptions Int
    -- ^ Catch-all for unknown values
    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

-- Flags MessageFlags
-- | Various flags that can be set on a t'GI.Soup.Objects.Message.Message' to alter its
-- behavior.
data MessageFlags = 
      MessageFlagsNoRedirect
    -- ^ The session should not follow redirect
    --   (3xx) responses received by this message.
    | MessageFlagsCanRebuild
    -- ^ The caller will rebuild the request
    --   body if the message is restarted; see
    --   'GI.Soup.Structs.MessageBody.messageBodySetAccumulate' for more details.
    | MessageFlagsOverwriteChunks
    -- ^ Deprecated: equivalent to calling
    --   'GI.Soup.Structs.MessageBody.messageBodySetAccumulate' on the incoming message body
    --   (ie, t'GI.Soup.Objects.Message.Message':@/response_body/@ for a client-side request),
    --   passing 'P.False'.
    | MessageFlagsContentDecoded
    -- ^ Set by t'GI.Soup.Objects.ContentDecoder.ContentDecoder' to
    --   indicate that it has removed the Content-Encoding on a message (and
    --   so headers such as Content-Length may no longer accurately describe
    --   the body).
    | MessageFlagsCertificateTrusted
    -- ^ if set after an https response
    --   has been received, indicates that the server\'s SSL certificate is
    --   trusted according to the session\'s CA.
    | MessageFlagsNewConnection
    -- ^ Requests that the message should be
    --   sent on a newly-created connection, not reusing an existing
    --   persistent connection. Note that messages with non-idempotent
    --   t'GI.Soup.Objects.Message.Message':@/method/@s behave this way by default, unless
    --   @/SOUP_MESSAGE_IDEMPOTENT/@ is set.
    | MessageFlagsIdempotent
    -- ^ The message is considered idempotent,
    --   regardless its t'GI.Soup.Objects.Message.Message':@/method/@, and allows reuse of existing
    --   idle connections, instead of always requiring a new one, unless
    --   @/SOUP_MESSAGE_NEW_CONNECTION/@ is set.
    | MessageFlagsIgnoreConnectionLimits
    -- ^ Request that a new connection is
    --   created for the message if there aren\'t idle connections available
    --   and it\'s not possible to create new connections due to any of the
    --   connection limits has been reached. If a dedicated connection is
    --   eventually created for this message, it will be dropped when the
    --   message finishes. Since 2.50
    | MessageFlagsDoNotUseAuthCache
    -- ^ The t'GI.Soup.Objects.AuthManager.AuthManager' should not use
    --   the credentials cache for this message, neither to use cached credentials
    --   to automatically authenticate this message nor to cache the credentials
    --   after the message is successfully authenticated. This applies to both server
    --   and proxy authentication. Note that [authenticate]("GI.Soup.Objects.Session#g:signal:authenticate") signal will
    --   be emitted, if you want to disable authentication for a message use
    --   'GI.Soup.Objects.Message.messageDisableFeature' passing @/SOUP_TYPE_AUTH_MANAGER/@ instead. Since 2.58
    | AnotherMessageFlags Int
    -- ^ Catch-all for unknown values
    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

-- Flags Expectation
-- | Represents the parsed value of the \"Expect\" header.
data Expectation = 
      ExpectationUnrecognized
    -- ^ any unrecognized expectation
    | ExpectationContinue
    -- ^ \"100-continue\"
    | AnotherExpectation Int
    -- ^ Catch-all for unknown values
    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

-- Flags Cacheability
-- | /No description available in the introspection data./
data Cacheability = 
      CacheabilityCacheable
    -- ^ /No description available in the introspection data./
    | CacheabilityUncacheable
    -- ^ /No description available in the introspection data./
    | CacheabilityInvalidates
    -- ^ /No description available in the introspection data./
    | CacheabilityValidates
    -- ^ /No description available in the introspection data./
    | AnotherCacheability Int
    -- ^ Catch-all for unknown values
    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