{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.WebKit2.Objects.URIRequest
    ( 

-- * Exported types
    URIRequest(..)                          ,
    IsURIRequest                            ,
    toURIRequest                            ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveURIRequestMethod                 ,
#endif


-- ** getHttpHeaders #method:getHttpHeaders#

#if defined(ENABLE_OVERLOADING)
    URIRequestGetHttpHeadersMethodInfo      ,
#endif
    uRIRequestGetHttpHeaders                ,


-- ** getHttpMethod #method:getHttpMethod#

#if defined(ENABLE_OVERLOADING)
    URIRequestGetHttpMethodMethodInfo       ,
#endif
    uRIRequestGetHttpMethod                 ,


-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    URIRequestGetUriMethodInfo              ,
#endif
    uRIRequestGetUri                        ,


-- ** new #method:new#

    uRIRequestNew                           ,


-- ** setUri #method:setUri#

#if defined(ENABLE_OVERLOADING)
    URIRequestSetUriMethodInfo              ,
#endif
    uRIRequestSetUri                        ,




 -- * Properties
-- ** uri #attr:uri#
-- | The URI to which the request will be made.

#if defined(ENABLE_OVERLOADING)
    URIRequestUriPropertyInfo               ,
#endif
    constructURIRequestUri                  ,
    getURIRequestUri                        ,
    setURIRequestUri                        ,
#if defined(ENABLE_OVERLOADING)
    uRIRequestUri                           ,
#endif




    ) 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.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders

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

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

foreign import ccall "webkit_uri_request_get_type"
    c_webkit_uri_request_get_type :: IO B.Types.GType

instance B.Types.TypedObject URIRequest where
    glibType :: IO GType
glibType = IO GType
c_webkit_uri_request_get_type

instance B.Types.GObject URIRequest

-- | Convert 'URIRequest' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue URIRequest where
    toGValue :: URIRequest -> IO GValue
toGValue URIRequest
o = do
        GType
gtype <- IO GType
c_webkit_uri_request_get_type
        URIRequest -> (Ptr URIRequest -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr URIRequest
o (GType
-> (GValue -> Ptr URIRequest -> IO ())
-> Ptr URIRequest
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr URIRequest -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO URIRequest
fromGValue GValue
gv = do
        Ptr URIRequest
ptr <- GValue -> IO (Ptr URIRequest)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr URIRequest)
        (ManagedPtr URIRequest -> URIRequest)
-> Ptr URIRequest -> IO URIRequest
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr URIRequest -> URIRequest
URIRequest Ptr URIRequest
ptr
        
    

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

instance O.HasParentTypes URIRequest
type instance O.ParentTypes URIRequest = '[GObject.Object.Object]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveURIRequestMethod (t :: Symbol) (o :: *) :: * where
    ResolveURIRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveURIRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveURIRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveURIRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveURIRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveURIRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveURIRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveURIRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveURIRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveURIRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveURIRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveURIRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveURIRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveURIRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveURIRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveURIRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveURIRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveURIRequestMethod "getHttpHeaders" o = URIRequestGetHttpHeadersMethodInfo
    ResolveURIRequestMethod "getHttpMethod" o = URIRequestGetHttpMethodMethodInfo
    ResolveURIRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveURIRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveURIRequestMethod "getUri" o = URIRequestGetUriMethodInfo
    ResolveURIRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveURIRequestMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveURIRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveURIRequestMethod "setUri" o = URIRequestSetUriMethodInfo
    ResolveURIRequestMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uRIRequest #uri
-- @
getURIRequestUri :: (MonadIO m, IsURIRequest o) => o -> m T.Text
getURIRequestUri :: o -> m Text
getURIRequestUri o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getURIRequestUri" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"uri"

-- | Set the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' uRIRequest [ #uri 'Data.GI.Base.Attributes.:=' value ]
-- @
setURIRequestUri :: (MonadIO m, IsURIRequest o) => o -> T.Text -> m ()
setURIRequestUri :: o -> Text -> m ()
setURIRequestUri o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"uri" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructURIRequestUri :: (IsURIRequest o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructURIRequestUri :: Text -> m (GValueConstruct o)
constructURIRequestUri Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"uri" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data URIRequestUriPropertyInfo
instance AttrInfo URIRequestUriPropertyInfo where
    type AttrAllowedOps URIRequestUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint URIRequestUriPropertyInfo = IsURIRequest
    type AttrSetTypeConstraint URIRequestUriPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint URIRequestUriPropertyInfo = (~) T.Text
    type AttrTransferType URIRequestUriPropertyInfo = T.Text
    type AttrGetType URIRequestUriPropertyInfo = T.Text
    type AttrLabel URIRequestUriPropertyInfo = "uri"
    type AttrOrigin URIRequestUriPropertyInfo = URIRequest
    attrGet = getURIRequestUri
    attrSet = setURIRequestUri
    attrTransfer _ v = do
        return v
    attrConstruct = constructURIRequestUri
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList URIRequest
type instance O.AttributeList URIRequest = URIRequestAttributeList
type URIRequestAttributeList = ('[ '("uri", URIRequestUriPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
uRIRequestUri :: AttrLabelProxy "uri"
uRIRequestUri = AttrLabelProxy

#endif

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

#endif

-- method URIRequest::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "WebKit2" , name = "URIRequest" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_uri_request_new" webkit_uri_request_new :: 
    CString ->                              -- uri : TBasicType TUTF8
    IO (Ptr URIRequest)

-- | Creates a new t'GI.WebKit2.Objects.URIRequest.URIRequest' for the given URI.
uRIRequestNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uri@/: an URI
    -> m URIRequest
    -- ^ __Returns:__ a new t'GI.WebKit2.Objects.URIRequest.URIRequest'
uRIRequestNew :: Text -> m URIRequest
uRIRequestNew Text
uri = IO URIRequest -> m URIRequest
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO URIRequest -> m URIRequest) -> IO URIRequest -> m URIRequest
forall a b. (a -> b) -> a -> b
$ do
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    Ptr URIRequest
result <- CString -> IO (Ptr URIRequest)
webkit_uri_request_new CString
uri'
    Text -> Ptr URIRequest -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIRequestNew" Ptr URIRequest
result
    URIRequest
result' <- ((ManagedPtr URIRequest -> URIRequest)
-> Ptr URIRequest -> IO URIRequest
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr URIRequest -> URIRequest
URIRequest) Ptr URIRequest
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
    URIRequest -> IO URIRequest
forall (m :: * -> *) a. Monad m => a -> m a
return URIRequest
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "webkit_uri_request_get_http_headers" webkit_uri_request_get_http_headers :: 
    Ptr URIRequest ->                       -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Get the HTTP headers of a t'GI.WebKit2.Objects.URIRequest.URIRequest' as a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'.
uRIRequestGetHttpHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) =>
    a
    -- ^ /@request@/: a t'GI.WebKit2.Objects.URIRequest.URIRequest'
    -> m (Maybe Soup.MessageHeaders.MessageHeaders)
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageHeaders.MessageHeaders' with the HTTP headers of /@request@/
    --    or 'P.Nothing' if /@request@/ is not an HTTP request.
uRIRequestGetHttpHeaders :: a -> m (Maybe MessageHeaders)
uRIRequestGetHttpHeaders a
request = IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders))
-> IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders)
forall a b. (a -> b) -> a -> b
$ do
    Ptr URIRequest
request' <- a -> IO (Ptr URIRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr MessageHeaders
result <- Ptr URIRequest -> IO (Ptr MessageHeaders)
webkit_uri_request_get_http_headers Ptr URIRequest
request'
    Maybe MessageHeaders
maybeResult <- Ptr MessageHeaders
-> (Ptr MessageHeaders -> IO MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MessageHeaders
result ((Ptr MessageHeaders -> IO MessageHeaders)
 -> IO (Maybe MessageHeaders))
-> (Ptr MessageHeaders -> IO MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHeaders
result' -> do
        MessageHeaders
result'' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result'
        MessageHeaders -> IO MessageHeaders
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Maybe MessageHeaders -> IO (Maybe MessageHeaders)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MessageHeaders
maybeResult

#if defined(ENABLE_OVERLOADING)
data URIRequestGetHttpHeadersMethodInfo
instance (signature ~ (m (Maybe Soup.MessageHeaders.MessageHeaders)), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetHttpHeadersMethodInfo a signature where
    overloadedMethod = uRIRequestGetHttpHeaders

#endif

-- method URIRequest::get_http_method
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "request"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "URIRequest" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitURIRequest"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_uri_request_get_http_method" webkit_uri_request_get_http_method :: 
    Ptr URIRequest ->                       -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"})
    IO CString

-- | Get the HTTP method of the t'GI.WebKit2.Objects.URIRequest.URIRequest'.
-- 
-- /Since: 2.12/
uRIRequestGetHttpMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) =>
    a
    -- ^ /@request@/: a t'GI.WebKit2.Objects.URIRequest.URIRequest'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the HTTP method of the t'GI.WebKit2.Objects.URIRequest.URIRequest' or 'P.Nothing' if /@request@/ is not
    --    an HTTP request.
uRIRequestGetHttpMethod :: a -> m (Maybe Text)
uRIRequestGetHttpMethod a
request = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr URIRequest
request' <- a -> IO (Ptr URIRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    CString
result <- Ptr URIRequest -> IO CString
webkit_uri_request_get_http_method Ptr URIRequest
request'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data URIRequestGetHttpMethodMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetHttpMethodMethodInfo a signature where
    overloadedMethod = uRIRequestGetHttpMethod

#endif

-- method URIRequest::get_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "request"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "URIRequest" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitURIRequest"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_uri_request_get_uri" webkit_uri_request_get_uri :: 
    Ptr URIRequest ->                       -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"})
    IO CString

-- | /No description available in the introspection data./
uRIRequestGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) =>
    a
    -- ^ /@request@/: a t'GI.WebKit2.Objects.URIRequest.URIRequest'
    -> m T.Text
    -- ^ __Returns:__ the uri of the t'GI.WebKit2.Objects.URIRequest.URIRequest'
uRIRequestGetUri :: a -> m Text
uRIRequestGetUri a
request = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr URIRequest
request' <- a -> IO (Ptr URIRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    CString
result <- Ptr URIRequest -> IO CString
webkit_uri_request_get_uri Ptr URIRequest
request'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIRequestGetUri" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data URIRequestGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetUriMethodInfo a signature where
    overloadedMethod = uRIRequestGetUri

#endif

-- method URIRequest::set_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "request"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "URIRequest" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitURIRequest"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an URI" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_uri_request_set_uri" webkit_uri_request_set_uri :: 
    Ptr URIRequest ->                       -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"})
    CString ->                              -- uri : TBasicType TUTF8
    IO ()

-- | Set the URI of /@request@/
uRIRequestSetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) =>
    a
    -- ^ /@request@/: a t'GI.WebKit2.Objects.URIRequest.URIRequest'
    -> T.Text
    -- ^ /@uri@/: an URI
    -> m ()
uRIRequestSetUri :: a -> Text -> m ()
uRIRequestSetUri a
request Text
uri = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr URIRequest
request' <- a -> IO (Ptr URIRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    Ptr URIRequest -> CString -> IO ()
webkit_uri_request_set_uri Ptr URIRequest
request' CString
uri'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data URIRequestSetUriMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestSetUriMethodInfo a signature where
    overloadedMethod = uRIRequestSetUri

#endif