{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A 'GI.Soup.Structs.URI.URI' represents a (parsed) URI. 'GI.Soup.Structs.URI.URI' supports RFC 3986
(URI Generic Syntax), and can parse any valid URI. However, libsoup
only uses \"http\" and \"https\" URIs internally; You can use
@/SOUP_URI_VALID_FOR_HTTP()/@ to test if a 'GI.Soup.Structs.URI.URI' is a valid HTTP
URI.

/@scheme@/ will always be set in any URI. It is an interned string and
is always all lowercase. (If you parse a URI with a non-lowercase
scheme, it will be converted to lowercase.) The macros
@/SOUP_URI_SCHEME_HTTP/@ and @/SOUP_URI_SCHEME_HTTPS/@ provide the
interned values for \"http\" and \"https\" and can be compared against
URI /@scheme@/ values.

/@user@/ and /@password@/ are parsed as defined in the older URI specs
(ie, separated by a colon; RFC 3986 only talks about a single
\"userinfo\" field). Note that /@password@/ is not included in the
output of 'GI.Soup.Structs.URI.uRIToString'. libsoup does not normally use these
fields; authentication is handled via 'GI.Soup.Objects.Session.Session' signals.

/@host@/ contains the hostname, and /@port@/ the port specified in the
URI. If the URI doesn\'t contain a hostname, /@host@/ will be 'Nothing',
and if it doesn\'t specify a port, /@port@/ may be 0. However, for
\"http\" and \"https\" URIs, /@host@/ is guaranteed to be non-'Nothing'
(trying to parse an http URI with no /@host@/ will return 'Nothing'), and
/@port@/ will always be non-0 (because libsoup knows the default value
to use when it is not specified in the URI).

/@path@/ is always non-'Nothing'. For http\/https URIs, /@path@/ will never be
an empty string either; if the input URI has no path, the parsed
'GI.Soup.Structs.URI.URI' will have a /@path@/ of \"\/\".

/@query@/ and /@fragment@/ are optional for all URI types.
'GI.Soup.Functions.formDecode' may be useful for parsing /@query@/.

Note that /@path@/, /@query@/, and /@fragment@/ may contain
%\<!-- -->-encoded characters. 'GI.Soup.Structs.URI.uRINew' calls
'GI.Soup.Functions.uriNormalize' on them, but not 'GI.Soup.Functions.uriDecode'. This is
necessary to ensure that 'GI.Soup.Structs.URI.uRIToString' will generate a URI
that has exactly the same meaning as the original. (In theory,
'GI.Soup.Structs.URI.URI' should leave /@user@/, /@password@/, and /@host@/ partially-encoded
as well, but this would be more annoying than useful.)
-}

module GI.Soup.Structs.URI
    ( 

-- * Exported types
    URI(..)                                 ,
    newZeroURI                              ,
    noURI                                   ,


 -- * Methods
-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URICopyMethodInfo                       ,
#endif
    uRICopy                                 ,


-- ** copyHost #method:copyHost#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URICopyHostMethodInfo                   ,
#endif
    uRICopyHost                             ,


-- ** decode #method:decode#
    uRIDecode                               ,


-- ** encode #method:encode#
    uRIEncode                               ,


-- ** equal #method:equal#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIEqualMethodInfo                      ,
#endif
    uRIEqual                                ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIFreeMethodInfo                       ,
#endif
    uRIFree                                 ,


-- ** getFragment #method:getFragment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetFragmentMethodInfo                ,
#endif
    uRIGetFragment                          ,


-- ** getHost #method:getHost#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetHostMethodInfo                    ,
#endif
    uRIGetHost                              ,


-- ** getPassword #method:getPassword#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetPasswordMethodInfo                ,
#endif
    uRIGetPassword                          ,


-- ** getPath #method:getPath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetPathMethodInfo                    ,
#endif
    uRIGetPath                              ,


-- ** getPort #method:getPort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetPortMethodInfo                    ,
#endif
    uRIGetPort                              ,


-- ** getQuery #method:getQuery#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetQueryMethodInfo                   ,
#endif
    uRIGetQuery                             ,


-- ** getScheme #method:getScheme#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetSchemeMethodInfo                  ,
#endif
    uRIGetScheme                            ,


-- ** getUser #method:getUser#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIGetUserMethodInfo                    ,
#endif
    uRIGetUser                              ,


-- ** hostEqual #method:hostEqual#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIHostEqualMethodInfo                  ,
#endif
    uRIHostEqual                            ,


-- ** hostHash #method:hostHash#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIHostHashMethodInfo                   ,
#endif
    uRIHostHash                             ,


-- ** new #method:new#
    uRINew                                  ,


-- ** newWithBase #method:newWithBase#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URINewWithBaseMethodInfo                ,
#endif
    uRINewWithBase                          ,


-- ** normalize #method:normalize#
    uRINormalize                            ,


-- ** setFragment #method:setFragment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetFragmentMethodInfo                ,
#endif
    uRISetFragment                          ,


-- ** setHost #method:setHost#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetHostMethodInfo                    ,
#endif
    uRISetHost                              ,


-- ** setPassword #method:setPassword#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetPasswordMethodInfo                ,
#endif
    uRISetPassword                          ,


-- ** setPath #method:setPath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetPathMethodInfo                    ,
#endif
    uRISetPath                              ,


-- ** setPort #method:setPort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetPortMethodInfo                    ,
#endif
    uRISetPort                              ,


-- ** setQuery #method:setQuery#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetQueryMethodInfo                   ,
#endif
    uRISetQuery                             ,


-- ** setQueryFromForm #method:setQueryFromForm#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetQueryFromFormMethodInfo           ,
#endif
    uRISetQueryFromForm                     ,


-- ** setScheme #method:setScheme#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetSchemeMethodInfo                  ,
#endif
    uRISetScheme                            ,


-- ** setUser #method:setUser#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URISetUserMethodInfo                    ,
#endif
    uRISetUser                              ,


-- ** toString #method:toString#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIToStringMethodInfo                   ,
#endif
    uRIToString                             ,


-- ** usesDefaultPort #method:usesDefaultPort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    URIUsesDefaultPortMethodInfo            ,
#endif
    uRIUsesDefaultPort                      ,




 -- * Properties
-- ** fragment #attr:fragment#
    clearURIFragment                        ,
    getURIFragment                          ,
    setURIFragment                          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_fragment                            ,
#endif


-- ** host #attr:host#
    clearURIHost                            ,
    getURIHost                              ,
    setURIHost                              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_host                                ,
#endif


-- ** password #attr:password#
    clearURIPassword                        ,
    getURIPassword                          ,
    setURIPassword                          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_password                            ,
#endif


-- ** path #attr:path#
    clearURIPath                            ,
    getURIPath                              ,
    setURIPath                              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_path                                ,
#endif


-- ** port #attr:port#
    getURIPort                              ,
    setURIPort                              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_port                                ,
#endif


-- ** query #attr:query#
    clearURIQuery                           ,
    getURIQuery                             ,
    setURIQuery                             ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_query                               ,
#endif


-- ** scheme #attr:scheme#
    clearURIScheme                          ,
    getURIScheme                            ,
    setURIScheme                            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_scheme                              ,
#endif


-- ** user #attr:user#
    clearURIUser                            ,
    getURIUser                              ,
    setURIUser                              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    uRI_user                                ,
#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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


newtype URI = URI (ManagedPtr URI)
foreign import ccall "soup_uri_get_type" c_soup_uri_get_type :: 
    IO GType

instance BoxedObject URI where
    boxedType _ = c_soup_uri_get_type

-- | Construct a `URI` struct initialized to zero.
newZeroURI :: MonadIO m => m URI
newZeroURI = liftIO $ callocBoxedBytes 64 >>= wrapBoxed URI

instance tag ~ 'AttrSet => Constructible URI tag where
    new _ attrs = do
        o <- newZeroURI
        GI.Attributes.set o attrs
        return o


noURI :: Maybe URI
noURI = Nothing

getURIScheme :: MonadIO m => URI -> m (Maybe T.Text)
getURIScheme s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIScheme :: MonadIO m => URI -> CString -> m ()
setURIScheme s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

clearURIScheme :: MonadIO m => URI -> m ()
clearURIScheme s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISchemeFieldInfo
instance AttrInfo URISchemeFieldInfo where
    type AttrAllowedOps URISchemeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URISchemeFieldInfo = (~) CString
    type AttrBaseTypeConstraint URISchemeFieldInfo = (~) URI
    type AttrGetType URISchemeFieldInfo = Maybe T.Text
    type AttrLabel URISchemeFieldInfo = "scheme"
    type AttrOrigin URISchemeFieldInfo = URI
    attrGet _ = getURIScheme
    attrSet _ = setURIScheme
    attrConstruct = undefined
    attrClear _ = clearURIScheme

uRI_scheme :: AttrLabelProxy "scheme"
uRI_scheme = AttrLabelProxy

#endif


getURIUser :: MonadIO m => URI -> m (Maybe T.Text)
getURIUser s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIUser :: MonadIO m => URI -> CString -> m ()
setURIUser s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: CString)

clearURIUser :: MonadIO m => URI -> m ()
clearURIUser s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIUserFieldInfo
instance AttrInfo URIUserFieldInfo where
    type AttrAllowedOps URIUserFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIUserFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIUserFieldInfo = (~) URI
    type AttrGetType URIUserFieldInfo = Maybe T.Text
    type AttrLabel URIUserFieldInfo = "user"
    type AttrOrigin URIUserFieldInfo = URI
    attrGet _ = getURIUser
    attrSet _ = setURIUser
    attrConstruct = undefined
    attrClear _ = clearURIUser

uRI_user :: AttrLabelProxy "user"
uRI_user = AttrLabelProxy

#endif


getURIPassword :: MonadIO m => URI -> m (Maybe T.Text)
getURIPassword s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIPassword :: MonadIO m => URI -> CString -> m ()
setURIPassword s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: CString)

clearURIPassword :: MonadIO m => URI -> m ()
clearURIPassword s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIPasswordFieldInfo
instance AttrInfo URIPasswordFieldInfo where
    type AttrAllowedOps URIPasswordFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIPasswordFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIPasswordFieldInfo = (~) URI
    type AttrGetType URIPasswordFieldInfo = Maybe T.Text
    type AttrLabel URIPasswordFieldInfo = "password"
    type AttrOrigin URIPasswordFieldInfo = URI
    attrGet _ = getURIPassword
    attrSet _ = setURIPassword
    attrConstruct = undefined
    attrClear _ = clearURIPassword

uRI_password :: AttrLabelProxy "password"
uRI_password = AttrLabelProxy

#endif


getURIHost :: MonadIO m => URI -> m (Maybe T.Text)
getURIHost s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIHost :: MonadIO m => URI -> CString -> m ()
setURIHost s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: CString)

clearURIHost :: MonadIO m => URI -> m ()
clearURIHost s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIHostFieldInfo
instance AttrInfo URIHostFieldInfo where
    type AttrAllowedOps URIHostFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIHostFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIHostFieldInfo = (~) URI
    type AttrGetType URIHostFieldInfo = Maybe T.Text
    type AttrLabel URIHostFieldInfo = "host"
    type AttrOrigin URIHostFieldInfo = URI
    attrGet _ = getURIHost
    attrSet _ = setURIHost
    attrConstruct = undefined
    attrClear _ = clearURIHost

uRI_host :: AttrLabelProxy "host"
uRI_host = AttrLabelProxy

#endif


getURIPort :: MonadIO m => URI -> m Word32
getURIPort s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

setURIPort :: MonadIO m => URI -> Word32 -> m ()
setURIPort s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIPortFieldInfo
instance AttrInfo URIPortFieldInfo where
    type AttrAllowedOps URIPortFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint URIPortFieldInfo = (~) Word32
    type AttrBaseTypeConstraint URIPortFieldInfo = (~) URI
    type AttrGetType URIPortFieldInfo = Word32
    type AttrLabel URIPortFieldInfo = "port"
    type AttrOrigin URIPortFieldInfo = URI
    attrGet _ = getURIPort
    attrSet _ = setURIPort
    attrConstruct = undefined
    attrClear _ = undefined

uRI_port :: AttrLabelProxy "port"
uRI_port = AttrLabelProxy

#endif


getURIPath :: MonadIO m => URI -> m (Maybe T.Text)
getURIPath s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIPath :: MonadIO m => URI -> CString -> m ()
setURIPath s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: CString)

clearURIPath :: MonadIO m => URI -> m ()
clearURIPath s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIPathFieldInfo
instance AttrInfo URIPathFieldInfo where
    type AttrAllowedOps URIPathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIPathFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIPathFieldInfo = (~) URI
    type AttrGetType URIPathFieldInfo = Maybe T.Text
    type AttrLabel URIPathFieldInfo = "path"
    type AttrOrigin URIPathFieldInfo = URI
    attrGet _ = getURIPath
    attrSet _ = setURIPath
    attrConstruct = undefined
    attrClear _ = clearURIPath

uRI_path :: AttrLabelProxy "path"
uRI_path = AttrLabelProxy

#endif


getURIQuery :: MonadIO m => URI -> m (Maybe T.Text)
getURIQuery s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIQuery :: MonadIO m => URI -> CString -> m ()
setURIQuery s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: CString)

clearURIQuery :: MonadIO m => URI -> m ()
clearURIQuery s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIQueryFieldInfo
instance AttrInfo URIQueryFieldInfo where
    type AttrAllowedOps URIQueryFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIQueryFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIQueryFieldInfo = (~) URI
    type AttrGetType URIQueryFieldInfo = Maybe T.Text
    type AttrLabel URIQueryFieldInfo = "query"
    type AttrOrigin URIQueryFieldInfo = URI
    attrGet _ = getURIQuery
    attrSet _ = setURIQuery
    attrConstruct = undefined
    attrClear _ = clearURIQuery

uRI_query :: AttrLabelProxy "query"
uRI_query = AttrLabelProxy

#endif


getURIFragment :: MonadIO m => URI -> m (Maybe T.Text)
getURIFragment s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setURIFragment :: MonadIO m => URI -> CString -> m ()
setURIFragment s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (val :: CString)

clearURIFragment :: MonadIO m => URI -> m ()
clearURIFragment s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIFragmentFieldInfo
instance AttrInfo URIFragmentFieldInfo where
    type AttrAllowedOps URIFragmentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint URIFragmentFieldInfo = (~) CString
    type AttrBaseTypeConstraint URIFragmentFieldInfo = (~) URI
    type AttrGetType URIFragmentFieldInfo = Maybe T.Text
    type AttrLabel URIFragmentFieldInfo = "fragment"
    type AttrOrigin URIFragmentFieldInfo = URI
    attrGet _ = getURIFragment
    attrSet _ = setURIFragment
    attrConstruct = undefined
    attrClear _ = clearURIFragment

uRI_fragment :: AttrLabelProxy "fragment"
uRI_fragment = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList URI
type instance O.AttributeList URI = URIAttributeList
type URIAttributeList = ('[ '("scheme", URISchemeFieldInfo), '("user", URIUserFieldInfo), '("password", URIPasswordFieldInfo), '("host", URIHostFieldInfo), '("port", URIPortFieldInfo), '("path", URIPathFieldInfo), '("query", URIQueryFieldInfo), '("fragment", URIFragmentFieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "soup_uri_new" soup_uri_new :: 
    CString ->                              -- uri_string : TBasicType TUTF8
    IO (Ptr URI)

{- |
Parses an absolute URI.

You can also pass 'Nothing' for /@uriString@/ if you want to get back an
\"empty\" 'GI.Soup.Structs.URI.URI' that you can fill in by hand. (You will need to
call at least 'GI.Soup.Structs.URI.uRISetScheme' and 'GI.Soup.Structs.URI.uRISetPath', since
those fields are required.)
-}
uRINew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@uriString@/: a URI -}
    -> m (Maybe URI)
    {- ^ __Returns:__ a 'GI.Soup.Structs.URI.URI', or 'Nothing' if the given string
 was found to be invalid. -}
uRINew uriString = liftIO $ do
    maybeUriString <- case uriString of
        Nothing -> return nullPtr
        Just jUriString -> do
            jUriString' <- textToCString jUriString
            return jUriString'
    result <- soup_uri_new maybeUriString
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed URI) result'
        return result''
    freeMem maybeUriString
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

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

foreign import ccall "soup_uri_copy" soup_uri_copy :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO (Ptr URI)

{- |
Copies /@uri@/
-}
uRICopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m URI
    {- ^ __Returns:__ a copy of /@uri@/, which must be freed with 'GI.Soup.Structs.URI.uRIFree' -}
uRICopy uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_copy uri'
    checkUnexpectedReturnNULL "uRICopy" result
    result' <- (wrapBoxed URI) result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URICopyMethodInfo
instance (signature ~ (m URI), MonadIO m) => O.MethodInfo URICopyMethodInfo URI signature where
    overloadedMethod _ = uRICopy

#endif

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

foreign import ccall "soup_uri_copy_host" soup_uri_copy_host :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO (Ptr URI)

{- |
Makes a copy of /@uri@/, considering only the protocol, host, and port

@since 2.28
-}
uRICopyHost ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m URI
    {- ^ __Returns:__ the new 'GI.Soup.Structs.URI.URI' -}
uRICopyHost uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_copy_host uri'
    checkUnexpectedReturnNULL "uRICopyHost" result
    result' <- (wrapBoxed URI) result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URICopyHostMethodInfo
instance (signature ~ (m URI), MonadIO m) => O.MethodInfo URICopyHostMethodInfo URI signature where
    overloadedMethod _ = uRICopyHost

#endif

-- method URI::equal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri1", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri2", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_equal" soup_uri_equal :: 
    Ptr URI ->                              -- uri1 : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr URI ->                              -- uri2 : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CInt

{- |
Tests whether or not /@uri1@/ and /@uri2@/ are equal in all parts
-}
uRIEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri1@/: a 'GI.Soup.Structs.URI.URI' -}
    -> URI
    {- ^ /@uri2@/: another 'GI.Soup.Structs.URI.URI' -}
    -> m Bool
    {- ^ __Returns:__ 'True' or 'False' -}
uRIEqual uri1 uri2 = liftIO $ do
    uri1' <- unsafeManagedPtrGetPtr uri1
    uri2' <- unsafeManagedPtrGetPtr uri2
    result <- soup_uri_equal uri1' uri2'
    let result' = (/= 0) result
    touchManagedPtr uri1
    touchManagedPtr uri2
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIEqualMethodInfo
instance (signature ~ (URI -> m Bool), MonadIO m) => O.MethodInfo URIEqualMethodInfo URI signature where
    overloadedMethod _ = uRIEqual

#endif

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

foreign import ccall "soup_uri_free" soup_uri_free :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO ()

{- |
Frees /@uri@/.
-}
uRIFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m ()
uRIFree uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    soup_uri_free uri'
    touchManagedPtr uri
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo URIFreeMethodInfo URI signature where
    overloadedMethod _ = uRIFree

#endif

-- method URI::get_fragment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_fragment" soup_uri_get_fragment :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s fragment.

@since 2.32
-}
uRIGetFragment ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s fragment. -}
uRIGetFragment uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_fragment uri'
    checkUnexpectedReturnNULL "uRIGetFragment" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetFragmentMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetFragmentMethodInfo URI signature where
    overloadedMethod _ = uRIGetFragment

#endif

-- method URI::get_host
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_host" soup_uri_get_host :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s host.

@since 2.32
-}
uRIGetHost ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s host. -}
uRIGetHost uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_host uri'
    checkUnexpectedReturnNULL "uRIGetHost" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetHostMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetHostMethodInfo URI signature where
    overloadedMethod _ = uRIGetHost

#endif

-- method URI::get_password
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_password" soup_uri_get_password :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s password.

@since 2.32
-}
uRIGetPassword ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s password. -}
uRIGetPassword uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_password uri'
    checkUnexpectedReturnNULL "uRIGetPassword" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetPasswordMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetPasswordMethodInfo URI signature where
    overloadedMethod _ = uRIGetPassword

#endif

-- method URI::get_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_path" soup_uri_get_path :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s path.

@since 2.32
-}
uRIGetPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s path. -}
uRIGetPath uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_path uri'
    checkUnexpectedReturnNULL "uRIGetPath" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetPathMethodInfo URI signature where
    overloadedMethod _ = uRIGetPath

#endif

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

foreign import ccall "soup_uri_get_port" soup_uri_get_port :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO Word32

{- |
Gets /@uri@/\'s port.

@since 2.32
-}
uRIGetPort ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m Word32
    {- ^ __Returns:__ /@uri@/\'s port. -}
uRIGetPort uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_port uri'
    touchManagedPtr uri
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetPortMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo URIGetPortMethodInfo URI signature where
    overloadedMethod _ = uRIGetPort

#endif

-- method URI::get_query
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_query" soup_uri_get_query :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s query.

@since 2.32
-}
uRIGetQuery ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s query. -}
uRIGetQuery uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_query uri'
    checkUnexpectedReturnNULL "uRIGetQuery" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetQueryMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetQueryMethodInfo URI signature where
    overloadedMethod _ = uRIGetQuery

#endif

-- method URI::get_scheme
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_scheme" soup_uri_get_scheme :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s scheme.

@since 2.32
-}
uRIGetScheme ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s scheme. -}
uRIGetScheme uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_scheme uri'
    checkUnexpectedReturnNULL "uRIGetScheme" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetSchemeMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetSchemeMethodInfo URI signature where
    overloadedMethod _ = uRIGetScheme

#endif

-- method URI::get_user
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", 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 "soup_uri_get_user" soup_uri_get_user :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CString

{- |
Gets /@uri@/\'s user.

@since 2.32
-}
uRIGetUser ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m T.Text
    {- ^ __Returns:__ /@uri@/\'s user. -}
uRIGetUser uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_get_user uri'
    checkUnexpectedReturnNULL "uRIGetUser" result
    result' <- cstringToText result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIGetUserMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo URIGetUserMethodInfo URI signature where
    overloadedMethod _ = uRIGetUser

#endif

-- method URI::host_equal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "v1", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI with a non-%NULL @host member", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "v2", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI with a non-%NULL @host member", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_host_equal" soup_uri_host_equal :: 
    Ptr URI ->                              -- v1 : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr URI ->                              -- v2 : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CInt

{- |
Compares /@v1@/ and /@v2@/, considering only the scheme, host, and port.

@since 2.28
-}
uRIHostEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@v1@/: a 'GI.Soup.Structs.URI.URI' with a non-'Nothing' /@host@/ member -}
    -> URI
    {- ^ /@v2@/: a 'GI.Soup.Structs.URI.URI' with a non-'Nothing' /@host@/ member -}
    -> m Bool
    {- ^ __Returns:__ whether or not the URIs are equal in scheme, host,
and port. -}
uRIHostEqual v1 v2 = liftIO $ do
    v1' <- unsafeManagedPtrGetPtr v1
    v2' <- unsafeManagedPtrGetPtr v2
    result <- soup_uri_host_equal v1' v2'
    let result' = (/= 0) result
    touchManagedPtr v1
    touchManagedPtr v2
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIHostEqualMethodInfo
instance (signature ~ (URI -> m Bool), MonadIO m) => O.MethodInfo URIHostEqualMethodInfo URI signature where
    overloadedMethod _ = uRIHostEqual

#endif

-- method URI::host_hash
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "key", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI with a non-%NULL @host member", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_host_hash" soup_uri_host_hash :: 
    Ptr URI ->                              -- key : TInterface (Name {namespace = "Soup", name = "URI"})
    IO Word32

{- |
Hashes /@key@/, considering only the scheme, host, and port.

@since 2.28
-}
uRIHostHash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@key@/: a 'GI.Soup.Structs.URI.URI' with a non-'Nothing' /@host@/ member -}
    -> m Word32
    {- ^ __Returns:__ a hash -}
uRIHostHash key = liftIO $ do
    key' <- unsafeManagedPtrGetPtr key
    result <- soup_uri_host_hash key'
    touchManagedPtr key
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIHostHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo URIHostHashMethodInfo URI signature where
    overloadedMethod _ = uRIHostHash

#endif

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

foreign import ccall "soup_uri_new_with_base" soup_uri_new_with_base :: 
    Ptr URI ->                              -- base : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- uri_string : TBasicType TUTF8
    IO (Ptr URI)

{- |
Parses /@uriString@/ relative to /@base@/.
-}
uRINewWithBase ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@base@/: a base URI -}
    -> T.Text
    {- ^ /@uriString@/: the URI -}
    -> m URI
    {- ^ __Returns:__ a parsed 'GI.Soup.Structs.URI.URI'. -}
uRINewWithBase base uriString = liftIO $ do
    base' <- unsafeManagedPtrGetPtr base
    uriString' <- textToCString uriString
    result <- soup_uri_new_with_base base' uriString'
    checkUnexpectedReturnNULL "uRINewWithBase" result
    result' <- (wrapBoxed URI) result
    touchManagedPtr base
    freeMem uriString'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URINewWithBaseMethodInfo
instance (signature ~ (T.Text -> m URI), MonadIO m) => O.MethodInfo URINewWithBaseMethodInfo URI signature where
    overloadedMethod _ = uRINewWithBase

#endif

-- method URI::set_fragment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the fragment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_fragment" soup_uri_set_fragment :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- fragment : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s fragment to /@fragment@/.
-}
uRISetFragment ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Maybe (T.Text)
    {- ^ /@fragment@/: the fragment -}
    -> m ()
uRISetFragment uri fragment = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    maybeFragment <- case fragment of
        Nothing -> return nullPtr
        Just jFragment -> do
            jFragment' <- textToCString jFragment
            return jFragment'
    soup_uri_set_fragment uri' maybeFragment
    touchManagedPtr uri
    freeMem maybeFragment
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetFragmentMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo URISetFragmentMethodInfo URI signature where
    overloadedMethod _ = uRISetFragment

#endif

-- method URI::set_host
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the hostname or IP address, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_host" soup_uri_set_host :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- host : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s host to /@host@/.

If /@host@/ is an IPv6 IP address, it should not include the brackets
required by the URI syntax; they will be added automatically when
converting /@uri@/ to a string.

http and https URIs should not have a 'Nothing' /@host@/.
-}
uRISetHost ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Maybe (T.Text)
    {- ^ /@host@/: the hostname or IP address, or 'Nothing' -}
    -> m ()
uRISetHost uri host = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    maybeHost <- case host of
        Nothing -> return nullPtr
        Just jHost -> do
            jHost' <- textToCString jHost
            return jHost'
    soup_uri_set_host uri' maybeHost
    touchManagedPtr uri
    freeMem maybeHost
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetHostMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo URISetHostMethodInfo URI signature where
    overloadedMethod _ = uRISetHost

#endif

-- method URI::set_password
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the password, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_password" soup_uri_set_password :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- password : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s password to /@password@/.
-}
uRISetPassword ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Maybe (T.Text)
    {- ^ /@password@/: the password, or 'Nothing' -}
    -> m ()
uRISetPassword uri password = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    maybePassword <- case password of
        Nothing -> return nullPtr
        Just jPassword -> do
            jPassword' <- textToCString jPassword
            return jPassword'
    soup_uri_set_password uri' maybePassword
    touchManagedPtr uri
    freeMem maybePassword
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetPasswordMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo URISetPasswordMethodInfo URI signature where
    overloadedMethod _ = uRISetPassword

#endif

-- method URI::set_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the non-%NULL path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_path" soup_uri_set_path :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- path : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s path to /@path@/.
-}
uRISetPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> T.Text
    {- ^ /@path@/: the non-'Nothing' path -}
    -> m ()
uRISetPath uri path = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    path' <- textToCString path
    soup_uri_set_path uri' path'
    touchManagedPtr uri
    freeMem path'
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo URISetPathMethodInfo URI signature where
    overloadedMethod _ = uRISetPath

#endif

-- method URI::set_port
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the port, or 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_port" soup_uri_set_port :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Word32 ->                               -- port : TBasicType TUInt
    IO ()

{- |
Sets /@uri@/\'s port to /@port@/. If /@port@/ is 0, /@uri@/ will not have an
explicitly-specified port.
-}
uRISetPort ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Word32
    {- ^ /@port@/: the port, or 0 -}
    -> m ()
uRISetPort uri port = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    soup_uri_set_port uri' port
    touchManagedPtr uri
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetPortMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo URISetPortMethodInfo URI signature where
    overloadedMethod _ = uRISetPort

#endif

-- method URI::set_query
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_query" soup_uri_set_query :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- query : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s query to /@query@/.
-}
uRISetQuery ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Maybe (T.Text)
    {- ^ /@query@/: the query -}
    -> m ()
uRISetQuery uri query = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    maybeQuery <- case query of
        Nothing -> return nullPtr
        Just jQuery -> do
            jQuery' <- textToCString jQuery
            return jQuery'
    soup_uri_set_query uri' maybeQuery
    touchManagedPtr uri
    freeMem maybeQuery
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetQueryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo URISetQueryMethodInfo URI signature where
    overloadedMethod _ = uRISetQuery

#endif

-- method URI::set_query_from_form
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "form", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GHashTable containing HTML form\ninformation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_query_from_form" soup_uri_set_query_from_form :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr (GHashTable CString CString) ->     -- form : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

{- |
Sets /@uri@/\'s query to the result of encoding /@form@/ according to the
HTML form rules. See 'GI.Soup.Functions.formEncodeHash' for more information.
-}
uRISetQueryFromForm ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Map.Map T.Text T.Text
    {- ^ /@form@/: a 'GI.GLib.Structs.HashTable.HashTable' containing HTML form
information -}
    -> m ()
uRISetQueryFromForm uri form = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    let form' = Map.toList form
    form'' <- mapFirstA textToCString form'
    form''' <- mapSecondA textToCString form''
    let form'''' = mapFirst cstringPackPtr form'''
    let form''''' = mapSecond cstringPackPtr form''''
    form'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) form'''''
    soup_uri_set_query_from_form uri' form''''''
    touchManagedPtr uri
    unrefGHashTable form''''''
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetQueryFromFormMethodInfo
instance (signature ~ (Map.Map T.Text T.Text -> m ()), MonadIO m) => O.MethodInfo URISetQueryFromFormMethodInfo URI signature where
    overloadedMethod _ = uRISetQueryFromForm

#endif

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

foreign import ccall "soup_uri_set_scheme" soup_uri_set_scheme :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- scheme : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s scheme to /@scheme@/. This will also set /@uri@/\'s port to
the default port for /@scheme@/, if known.
-}
uRISetScheme ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> T.Text
    {- ^ /@scheme@/: the URI scheme -}
    -> m ()
uRISetScheme uri scheme = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    scheme' <- textToCString scheme
    soup_uri_set_scheme uri' scheme'
    touchManagedPtr uri
    freeMem scheme'
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetSchemeMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo URISetSchemeMethodInfo URI signature where
    overloadedMethod _ = uRISetScheme

#endif

-- method URI::set_user
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the username, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_set_user" soup_uri_set_user :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- user : TBasicType TUTF8
    IO ()

{- |
Sets /@uri@/\'s user to /@user@/.
-}
uRISetUser ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Maybe (T.Text)
    {- ^ /@user@/: the username, or 'Nothing' -}
    -> m ()
uRISetUser uri user = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    maybeUser <- case user of
        Nothing -> return nullPtr
        Just jUser -> do
            jUser' <- textToCString jUser
            return jUser'
    soup_uri_set_user uri' maybeUser
    touchManagedPtr uri
    freeMem maybeUser
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URISetUserMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo URISetUserMethodInfo URI signature where
    overloadedMethod _ = uRISetUser

#endif

-- method URI::to_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "just_path_and_query", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, output just the path and query portions", 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 "soup_uri_to_string" soup_uri_to_string :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CInt ->                                 -- just_path_and_query : TBasicType TBoolean
    IO CString

{- |
Returns a string representing /@uri@/.

If /@justPathAndQuery@/ is 'True', this concatenates the path and query
together. That is, it constructs the string that would be needed in
the Request-Line of an HTTP request for /@uri@/.

Note that the output will never contain a password, even if /@uri@/
does.
-}
uRIToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Bool
    {- ^ /@justPathAndQuery@/: if 'True', output just the path and query portions -}
    -> m T.Text
    {- ^ __Returns:__ a string representing /@uri@/, which the caller must free. -}
uRIToString uri justPathAndQuery = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    let justPathAndQuery' = (fromIntegral . fromEnum) justPathAndQuery
    result <- soup_uri_to_string uri' justPathAndQuery'
    checkUnexpectedReturnNULL "uRIToString" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIToStringMethodInfo
instance (signature ~ (Bool -> m T.Text), MonadIO m) => O.MethodInfo URIToStringMethodInfo URI signature where
    overloadedMethod _ = uRIToString

#endif

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

foreign import ccall "soup_uri_uses_default_port" soup_uri_uses_default_port :: 
    Ptr URI ->                              -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CInt

{- |
Tests if /@uri@/ uses the default port for its scheme. (Eg, 80 for
http.) (This only works for http, https and ftp; libsoup does not know
the default ports of other protocols.)
-}
uRIUsesDefaultPort ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m Bool
    {- ^ __Returns:__ 'True' or 'False' -}
uRIUsesDefaultPort uri = liftIO $ do
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_uri_uses_default_port uri'
    let result' = (/= 0) result
    touchManagedPtr uri
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data URIUsesDefaultPortMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo URIUsesDefaultPortMethodInfo URI signature where
    overloadedMethod _ = uRIUsesDefaultPort

#endif

-- method URI::decode
-- method type : MemberFunction
-- Args : [Arg {argCName = "part", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI part", 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 "soup_uri_decode" soup_uri_decode :: 
    CString ->                              -- part : TBasicType TUTF8
    IO CString

{- |
Fully %\<!-- -->-decodes /@part@/.

In the past, this would return 'Nothing' if /@part@/ contained invalid
percent-encoding, but now it just ignores the problem (as
'GI.Soup.Structs.URI.uRINew' already did).
-}
uRIDecode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@part@/: a URI part -}
    -> m T.Text
    {- ^ __Returns:__ the decoded URI part. -}
uRIDecode part = liftIO $ do
    part' <- textToCString part
    result <- soup_uri_decode part'
    checkUnexpectedReturnNULL "uRIDecode" result
    result' <- cstringToText result
    freeMem result
    freeMem part'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method URI::encode
-- method type : MemberFunction
-- Args : [Arg {argCName = "part", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI part", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "escape_extra", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "additional reserved characters to\nescape (or %NULL)", 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 "soup_uri_encode" soup_uri_encode :: 
    CString ->                              -- part : TBasicType TUTF8
    CString ->                              -- escape_extra : TBasicType TUTF8
    IO CString

{- |
This %\<!-- -->-encodes the given URI part and returns the escaped
version in allocated memory, which the caller must free when it is
done.
-}
uRIEncode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@part@/: a URI part -}
    -> Maybe (T.Text)
    {- ^ /@escapeExtra@/: additional reserved characters to
escape (or 'Nothing') -}
    -> m T.Text
    {- ^ __Returns:__ the encoded URI part -}
uRIEncode part escapeExtra = liftIO $ do
    part' <- textToCString part
    maybeEscapeExtra <- case escapeExtra of
        Nothing -> return nullPtr
        Just jEscapeExtra -> do
            jEscapeExtra' <- textToCString jEscapeExtra
            return jEscapeExtra'
    result <- soup_uri_encode part' maybeEscapeExtra
    checkUnexpectedReturnNULL "uRIEncode" result
    result' <- cstringToText result
    freeMem result
    freeMem part'
    freeMem maybeEscapeExtra
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method URI::normalize
-- method type : MemberFunction
-- Args : [Arg {argCName = "part", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI part", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unescape_extra", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "reserved characters to unescape (or %NULL)", 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 "soup_uri_normalize" soup_uri_normalize :: 
    CString ->                              -- part : TBasicType TUTF8
    CString ->                              -- unescape_extra : TBasicType TUTF8
    IO CString

{- |
%\<!-- -->-decodes any \"unreserved\" characters (or characters in
/@unescapeExtra@/) in /@part@/, and %\<!-- -->-encodes any non-ASCII
characters, spaces, and non-printing characters in /@part@/.

\"Unreserved\" characters are those that are not allowed to be used
for punctuation according to the URI spec. For example, letters are
unreserved, so 'GI.Soup.Functions.uriNormalize' will turn
\<literal>http:\/\/example.com\/foo\/b%\<!-- -->61r\<\/literal> into
\<literal>http:\/\/example.com\/foo\/bar\<\/literal>, which is guaranteed
to mean the same thing. However, \"\/\" is \"reserved\", so
\<literal>http:\/\/example.com\/foo%\<!-- -->2Fbar\<\/literal> would not
be changed, because it might mean something different to the
server.

In the past, this would return 'Nothing' if /@part@/ contained invalid
percent-encoding, but now it just ignores the problem (as
'GI.Soup.Structs.URI.uRINew' already did).
-}
uRINormalize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@part@/: a URI part -}
    -> Maybe (T.Text)
    {- ^ /@unescapeExtra@/: reserved characters to unescape (or 'Nothing') -}
    -> m T.Text
    {- ^ __Returns:__ the normalized URI part -}
uRINormalize part unescapeExtra = liftIO $ do
    part' <- textToCString part
    maybeUnescapeExtra <- case unescapeExtra of
        Nothing -> return nullPtr
        Just jUnescapeExtra -> do
            jUnescapeExtra' <- textToCString jUnescapeExtra
            return jUnescapeExtra'
    result <- soup_uri_normalize part' maybeUnescapeExtra
    checkUnexpectedReturnNULL "uRINormalize" result
    result' <- cstringToText result
    freeMem result
    freeMem part'
    freeMem maybeUnescapeExtra
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveURIMethod (t :: Symbol) (o :: *) :: * where
    ResolveURIMethod "copy" o = URICopyMethodInfo
    ResolveURIMethod "copyHost" o = URICopyHostMethodInfo
    ResolveURIMethod "equal" o = URIEqualMethodInfo
    ResolveURIMethod "free" o = URIFreeMethodInfo
    ResolveURIMethod "hostEqual" o = URIHostEqualMethodInfo
    ResolveURIMethod "hostHash" o = URIHostHashMethodInfo
    ResolveURIMethod "newWithBase" o = URINewWithBaseMethodInfo
    ResolveURIMethod "toString" o = URIToStringMethodInfo
    ResolveURIMethod "usesDefaultPort" o = URIUsesDefaultPortMethodInfo
    ResolveURIMethod "getFragment" o = URIGetFragmentMethodInfo
    ResolveURIMethod "getHost" o = URIGetHostMethodInfo
    ResolveURIMethod "getPassword" o = URIGetPasswordMethodInfo
    ResolveURIMethod "getPath" o = URIGetPathMethodInfo
    ResolveURIMethod "getPort" o = URIGetPortMethodInfo
    ResolveURIMethod "getQuery" o = URIGetQueryMethodInfo
    ResolveURIMethod "getScheme" o = URIGetSchemeMethodInfo
    ResolveURIMethod "getUser" o = URIGetUserMethodInfo
    ResolveURIMethod "setFragment" o = URISetFragmentMethodInfo
    ResolveURIMethod "setHost" o = URISetHostMethodInfo
    ResolveURIMethod "setPassword" o = URISetPasswordMethodInfo
    ResolveURIMethod "setPath" o = URISetPathMethodInfo
    ResolveURIMethod "setPort" o = URISetPortMethodInfo
    ResolveURIMethod "setQuery" o = URISetQueryMethodInfo
    ResolveURIMethod "setQueryFromForm" o = URISetQueryFromFormMethodInfo
    ResolveURIMethod "setScheme" o = URISetSchemeMethodInfo
    ResolveURIMethod "setUser" o = URISetUserMethodInfo
    ResolveURIMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveURIMethod t URI, O.MethodInfo info URI p) => O.IsLabelProxy t (URI -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveURIMethod t URI, O.MethodInfo info URI p) => O.IsLabel t (URI -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif