{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Soup.Objects.RequestHTTP.RequestHTTP' implements t'GI.Soup.Objects.Request.Request' for \"http\" and \"https\"
-- URIs.
-- 
-- To do more complicated HTTP operations using the t'GI.Soup.Objects.Request.Request' APIs,
-- call 'GI.Soup.Objects.RequestHTTP.requestHTTPGetMessage' to get the request\'s
-- t'GI.Soup.Objects.Message.Message'.

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

module GI.Soup.Objects.RequestHTTP
    ( 

-- * Exported types
    RequestHTTP(..)                         ,
    IsRequestHTTP                           ,
    toRequestHTTP                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [init]("GI.Gio.Interfaces.Initable#g:method:init"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [send]("GI.Soup.Objects.Request#g:method:send"), [sendAsync]("GI.Soup.Objects.Request#g:method:sendAsync"), [sendFinish]("GI.Soup.Objects.Request#g:method:sendFinish"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getContentLength]("GI.Soup.Objects.Request#g:method:getContentLength"), [getContentType]("GI.Soup.Objects.Request#g:method:getContentType"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMessage]("GI.Soup.Objects.RequestHTTP#g:method:getMessage"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSession]("GI.Soup.Objects.Request#g:method:getSession"), [getUri]("GI.Soup.Objects.Request#g:method:getUri").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveRequestHTTPMethod                ,
#endif

-- ** getMessage #method:getMessage#

#if defined(ENABLE_OVERLOADING)
    RequestHTTPGetMessageMethodInfo         ,
#endif
    requestHTTPGetMessage                   ,




    ) 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
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Objects.Request as Soup.Request

-- | Memory-managed wrapper type.
newtype RequestHTTP = RequestHTTP (SP.ManagedPtr RequestHTTP)
    deriving (RequestHTTP -> RequestHTTP -> Bool
(RequestHTTP -> RequestHTTP -> Bool)
-> (RequestHTTP -> RequestHTTP -> Bool) -> Eq RequestHTTP
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RequestHTTP -> RequestHTTP -> Bool
$c/= :: RequestHTTP -> RequestHTTP -> Bool
== :: RequestHTTP -> RequestHTTP -> Bool
$c== :: RequestHTTP -> RequestHTTP -> Bool
Eq)

instance SP.ManagedPtrNewtype RequestHTTP where
    toManagedPtr :: RequestHTTP -> ManagedPtr RequestHTTP
toManagedPtr (RequestHTTP ManagedPtr RequestHTTP
p) = ManagedPtr RequestHTTP
p

foreign import ccall "soup_request_http_get_type"
    c_soup_request_http_get_type :: IO B.Types.GType

instance B.Types.TypedObject RequestHTTP where
    glibType :: IO GType
glibType = IO GType
c_soup_request_http_get_type

instance B.Types.GObject RequestHTTP

-- | Type class for types which can be safely cast to `RequestHTTP`, for instance with `toRequestHTTP`.
class (SP.GObject o, O.IsDescendantOf RequestHTTP o) => IsRequestHTTP o
instance (SP.GObject o, O.IsDescendantOf RequestHTTP o) => IsRequestHTTP o

instance O.HasParentTypes RequestHTTP
type instance O.ParentTypes RequestHTTP = '[Soup.Request.Request, GObject.Object.Object, Gio.Initable.Initable]

-- | Cast to `RequestHTTP`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toRequestHTTP :: (MIO.MonadIO m, IsRequestHTTP o) => o -> m RequestHTTP
toRequestHTTP :: forall (m :: * -> *) o.
(MonadIO m, IsRequestHTTP o) =>
o -> m RequestHTTP
toRequestHTTP = IO RequestHTTP -> m RequestHTTP
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO RequestHTTP -> m RequestHTTP)
-> (o -> IO RequestHTTP) -> o -> m RequestHTTP
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr RequestHTTP -> RequestHTTP) -> o -> IO RequestHTTP
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr RequestHTTP -> RequestHTTP
RequestHTTP

-- | Convert 'RequestHTTP' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe RequestHTTP) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_request_http_get_type
    gvalueSet_ :: Ptr GValue -> Maybe RequestHTTP -> IO ()
gvalueSet_ Ptr GValue
gv Maybe RequestHTTP
P.Nothing = Ptr GValue -> Ptr RequestHTTP -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr RequestHTTP
forall a. Ptr a
FP.nullPtr :: FP.Ptr RequestHTTP)
    gvalueSet_ Ptr GValue
gv (P.Just RequestHTTP
obj) = RequestHTTP -> (Ptr RequestHTTP -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RequestHTTP
obj (Ptr GValue -> Ptr RequestHTTP -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe RequestHTTP)
gvalueGet_ Ptr GValue
gv = do
        Ptr RequestHTTP
ptr <- Ptr GValue -> IO (Ptr RequestHTTP)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr RequestHTTP)
        if Ptr RequestHTTP
ptr Ptr RequestHTTP -> Ptr RequestHTTP -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr RequestHTTP
forall a. Ptr a
FP.nullPtr
        then RequestHTTP -> Maybe RequestHTTP
forall a. a -> Maybe a
P.Just (RequestHTTP -> Maybe RequestHTTP)
-> IO RequestHTTP -> IO (Maybe RequestHTTP)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr RequestHTTP -> RequestHTTP)
-> Ptr RequestHTTP -> IO RequestHTTP
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr RequestHTTP -> RequestHTTP
RequestHTTP Ptr RequestHTTP
ptr
        else Maybe RequestHTTP -> IO (Maybe RequestHTTP)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RequestHTTP
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveRequestHTTPMethod (t :: Symbol) (o :: *) :: * where
    ResolveRequestHTTPMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRequestHTTPMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRequestHTTPMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRequestHTTPMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRequestHTTPMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveRequestHTTPMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveRequestHTTPMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRequestHTTPMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRequestHTTPMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRequestHTTPMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRequestHTTPMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRequestHTTPMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRequestHTTPMethod "send" o = Soup.Request.RequestSendMethodInfo
    ResolveRequestHTTPMethod "sendAsync" o = Soup.Request.RequestSendAsyncMethodInfo
    ResolveRequestHTTPMethod "sendFinish" o = Soup.Request.RequestSendFinishMethodInfo
    ResolveRequestHTTPMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRequestHTTPMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRequestHTTPMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRequestHTTPMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRequestHTTPMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRequestHTTPMethod "getContentLength" o = Soup.Request.RequestGetContentLengthMethodInfo
    ResolveRequestHTTPMethod "getContentType" o = Soup.Request.RequestGetContentTypeMethodInfo
    ResolveRequestHTTPMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRequestHTTPMethod "getMessage" o = RequestHTTPGetMessageMethodInfo
    ResolveRequestHTTPMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRequestHTTPMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRequestHTTPMethod "getSession" o = Soup.Request.RequestGetSessionMethodInfo
    ResolveRequestHTTPMethod "getUri" o = Soup.Request.RequestGetUriMethodInfo
    ResolveRequestHTTPMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRequestHTTPMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveRequestHTTPMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRequestHTTPMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRequestHTTPMethod t RequestHTTP, O.OverloadedMethod info RequestHTTP p) => OL.IsLabel t (RequestHTTP -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRequestHTTPMethod t RequestHTTP, O.OverloadedMethod info RequestHTTP p, R.HasField t RequestHTTP p) => R.HasField t RequestHTTP p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRequestHTTPMethod t RequestHTTP, O.OverloadedMethodInfo info RequestHTTP) => OL.IsLabel t (O.MethodProxy info RequestHTTP) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RequestHTTP
type instance O.AttributeList RequestHTTP = RequestHTTPAttributeList
type RequestHTTPAttributeList = ('[ '("session", Soup.Request.RequestSessionPropertyInfo), '("uri", Soup.Request.RequestUriPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList RequestHTTP = RequestHTTPSignalList
type RequestHTTPSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method RequestHTTP::get_message
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "http"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "RequestHTTP" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupRequestHTTP object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_request_http_get_message" soup_request_http_get_message :: 
    Ptr RequestHTTP ->                      -- http : TInterface (Name {namespace = "Soup", name = "RequestHTTP"})
    IO (Ptr Soup.Message.Message)

-- | Gets a new reference to the t'GI.Soup.Objects.Message.Message' associated to this SoupRequest
-- 
-- /Since: 2.40/
requestHTTPGetMessage ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequestHTTP a) =>
    a
    -- ^ /@http@/: a t'GI.Soup.Objects.RequestHTTP.RequestHTTP' object
    -> m Soup.Message.Message
    -- ^ __Returns:__ a new reference to the t'GI.Soup.Objects.Message.Message'
requestHTTPGetMessage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRequestHTTP a) =>
a -> m Message
requestHTTPGetMessage a
http = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
    Ptr RequestHTTP
http' <- a -> IO (Ptr RequestHTTP)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
http
    Ptr Message
result <- Ptr RequestHTTP -> IO (Ptr Message)
soup_request_http_get_message Ptr RequestHTTP
http'
    Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"requestHTTPGetMessage" Ptr Message
result
    Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
http
    Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'

#if defined(ENABLE_OVERLOADING)
data RequestHTTPGetMessageMethodInfo
instance (signature ~ (m Soup.Message.Message), MonadIO m, IsRequestHTTP a) => O.OverloadedMethod RequestHTTPGetMessageMethodInfo a signature where
    overloadedMethod = requestHTTPGetMessage

instance O.OverloadedMethodInfo RequestHTTPGetMessageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Soup.Objects.RequestHTTP.requestHTTPGetMessage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Objects-RequestHTTP.html#v:requestHTTPGetMessage"
        }


#endif