{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.URI
(
URI(..) ,
newZeroURI ,
#if defined(ENABLE_OVERLOADING)
ResolveURIMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
URICopyMethodInfo ,
#endif
uRICopy ,
#if defined(ENABLE_OVERLOADING)
URICopyHostMethodInfo ,
#endif
uRICopyHost ,
uRIDecode ,
uRIEncode ,
#if defined(ENABLE_OVERLOADING)
URIEqualMethodInfo ,
#endif
uRIEqual ,
#if defined(ENABLE_OVERLOADING)
URIFreeMethodInfo ,
#endif
uRIFree ,
#if defined(ENABLE_OVERLOADING)
URIGetFragmentMethodInfo ,
#endif
uRIGetFragment ,
#if defined(ENABLE_OVERLOADING)
URIGetHostMethodInfo ,
#endif
uRIGetHost ,
#if defined(ENABLE_OVERLOADING)
URIGetPasswordMethodInfo ,
#endif
uRIGetPassword ,
#if defined(ENABLE_OVERLOADING)
URIGetPathMethodInfo ,
#endif
uRIGetPath ,
#if defined(ENABLE_OVERLOADING)
URIGetPortMethodInfo ,
#endif
uRIGetPort ,
#if defined(ENABLE_OVERLOADING)
URIGetQueryMethodInfo ,
#endif
uRIGetQuery ,
#if defined(ENABLE_OVERLOADING)
URIGetSchemeMethodInfo ,
#endif
uRIGetScheme ,
#if defined(ENABLE_OVERLOADING)
URIGetUserMethodInfo ,
#endif
uRIGetUser ,
#if defined(ENABLE_OVERLOADING)
URIHostEqualMethodInfo ,
#endif
uRIHostEqual ,
#if defined(ENABLE_OVERLOADING)
URIHostHashMethodInfo ,
#endif
uRIHostHash ,
uRINew ,
uRINewWithBase ,
uRINormalize ,
#if defined(ENABLE_OVERLOADING)
URISetFragmentMethodInfo ,
#endif
uRISetFragment ,
#if defined(ENABLE_OVERLOADING)
URISetHostMethodInfo ,
#endif
uRISetHost ,
#if defined(ENABLE_OVERLOADING)
URISetPasswordMethodInfo ,
#endif
uRISetPassword ,
#if defined(ENABLE_OVERLOADING)
URISetPathMethodInfo ,
#endif
uRISetPath ,
#if defined(ENABLE_OVERLOADING)
URISetPortMethodInfo ,
#endif
uRISetPort ,
#if defined(ENABLE_OVERLOADING)
URISetQueryMethodInfo ,
#endif
uRISetQuery ,
#if defined(ENABLE_OVERLOADING)
URISetQueryFromFormMethodInfo ,
#endif
uRISetQueryFromForm ,
#if defined(ENABLE_OVERLOADING)
URISetSchemeMethodInfo ,
#endif
uRISetScheme ,
#if defined(ENABLE_OVERLOADING)
URISetUserMethodInfo ,
#endif
uRISetUser ,
#if defined(ENABLE_OVERLOADING)
URIToStringMethodInfo ,
#endif
uRIToString ,
#if defined(ENABLE_OVERLOADING)
URIUsesDefaultPortMethodInfo ,
#endif
uRIUsesDefaultPort ,
clearURIFragment ,
getURIFragment ,
setURIFragment ,
#if defined(ENABLE_OVERLOADING)
uRI_fragment ,
#endif
clearURIHost ,
getURIHost ,
setURIHost ,
#if defined(ENABLE_OVERLOADING)
uRI_host ,
#endif
clearURIPassword ,
getURIPassword ,
setURIPassword ,
#if defined(ENABLE_OVERLOADING)
uRI_password ,
#endif
clearURIPath ,
getURIPath ,
setURIPath ,
#if defined(ENABLE_OVERLOADING)
uRI_path ,
#endif
getURIPort ,
setURIPort ,
#if defined(ENABLE_OVERLOADING)
uRI_port ,
#endif
clearURIQuery ,
getURIQuery ,
setURIQuery ,
#if defined(ENABLE_OVERLOADING)
uRI_query ,
#endif
clearURIScheme ,
getURIScheme ,
setURIScheme ,
#if defined(ENABLE_OVERLOADING)
uRI_scheme ,
#endif
clearURIUser ,
getURIUser ,
setURIUser ,
#if defined(ENABLE_OVERLOADING)
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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
newtype URI = URI (SP.ManagedPtr URI)
deriving (URI -> URI -> Bool
(URI -> URI -> Bool) -> (URI -> URI -> Bool) -> Eq URI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: URI -> URI -> Bool
$c/= :: URI -> URI -> Bool
== :: URI -> URI -> Bool
$c== :: URI -> URI -> Bool
Eq)
instance SP.ManagedPtrNewtype URI where
toManagedPtr :: URI -> ManagedPtr URI
toManagedPtr (URI ManagedPtr URI
p) = ManagedPtr URI
p
foreign import ccall "soup_uri_get_type" c_soup_uri_get_type ::
IO GType
type instance O.ParentTypes URI = '[]
instance O.HasParentTypes URI
instance B.Types.TypedObject URI where
glibType :: IO GType
glibType = IO GType
c_soup_uri_get_type
instance B.Types.GBoxed URI
instance B.GValue.IsGValue (Maybe URI) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_uri_get_type
gvalueSet_ :: Ptr GValue -> Maybe URI -> IO ()
gvalueSet_ Ptr GValue
gv Maybe URI
P.Nothing = Ptr GValue -> Ptr URI -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr URI
forall a. Ptr a
FP.nullPtr :: FP.Ptr URI)
gvalueSet_ Ptr GValue
gv (P.Just URI
obj) = URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr URI
obj (Ptr GValue -> Ptr URI -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe URI)
gvalueGet_ Ptr GValue
gv = do
Ptr URI
ptr <- Ptr GValue -> IO (Ptr URI)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr URI)
if Ptr URI
ptr Ptr URI -> Ptr URI -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr URI
forall a. Ptr a
FP.nullPtr
then URI -> Maybe URI
forall a. a -> Maybe a
P.Just (URI -> Maybe URI) -> IO URI -> IO (Maybe URI)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr URI -> URI
URI Ptr URI
ptr
else Maybe URI -> IO (Maybe URI)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe URI
forall a. Maybe a
P.Nothing
newZeroURI :: MonadIO m => m URI
newZeroURI :: forall (m :: * -> *). MonadIO m => m URI
newZeroURI = IO URI -> m URI
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO URI -> m URI) -> IO URI -> m URI
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr URI)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr URI) -> (Ptr URI -> IO URI) -> IO URI
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
URI
instance tag ~ 'AttrSet => Constructible URI tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr URI -> URI) -> [AttrOp URI tag] -> m URI
new ManagedPtr URI -> URI
_ [AttrOp URI tag]
attrs = do
URI
o <- m URI
forall (m :: * -> *). MonadIO m => m URI
newZeroURI
URI -> [AttrOp URI 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set URI
o [AttrOp URI tag]
[AttrOp URI 'AttrSet]
attrs
URI -> m URI
forall (m :: * -> *) a. Monad m => a -> m a
return URI
o
getURIScheme :: MonadIO m => URI -> m (Maybe T.Text)
getURIScheme :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIScheme URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIScheme :: MonadIO m => URI -> CString -> m ()
setURIScheme :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIScheme URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearURIScheme :: MonadIO m => URI -> m ()
clearURIScheme :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIScheme URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URISchemeFieldInfo
instance AttrInfo URISchemeFieldInfo where
type AttrBaseTypeConstraint URISchemeFieldInfo = (~) URI
type AttrAllowedOps URISchemeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URISchemeFieldInfo = (~) CString
type AttrTransferTypeConstraint URISchemeFieldInfo = (~)CString
type AttrTransferType URISchemeFieldInfo = CString
type AttrGetType URISchemeFieldInfo = Maybe T.Text
type AttrLabel URISchemeFieldInfo = "scheme"
type AttrOrigin URISchemeFieldInfo = URI
attrGet = getURIScheme
attrSet = setURIScheme
attrConstruct = undefined
attrClear = clearURIScheme
attrTransfer _ v = do
return v
uRI_scheme :: AttrLabelProxy "scheme"
uRI_scheme = AttrLabelProxy
#endif
getURIUser :: MonadIO m => URI -> m (Maybe T.Text)
getURIUser :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIUser URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIUser :: MonadIO m => URI -> CString -> m ()
setURIUser :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIUser URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
val :: CString)
clearURIUser :: MonadIO m => URI -> m ()
clearURIUser :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIUser URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIUserFieldInfo
instance AttrInfo URIUserFieldInfo where
type AttrBaseTypeConstraint URIUserFieldInfo = (~) URI
type AttrAllowedOps URIUserFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIUserFieldInfo = (~) CString
type AttrTransferTypeConstraint URIUserFieldInfo = (~)CString
type AttrTransferType URIUserFieldInfo = CString
type AttrGetType URIUserFieldInfo = Maybe T.Text
type AttrLabel URIUserFieldInfo = "user"
type AttrOrigin URIUserFieldInfo = URI
attrGet = getURIUser
attrSet = setURIUser
attrConstruct = undefined
attrClear = clearURIUser
attrTransfer _ v = do
return v
uRI_user :: AttrLabelProxy "user"
uRI_user = AttrLabelProxy
#endif
getURIPassword :: MonadIO m => URI -> m (Maybe T.Text)
getURIPassword :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIPassword URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIPassword :: MonadIO m => URI -> CString -> m ()
setURIPassword :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIPassword URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)
clearURIPassword :: MonadIO m => URI -> m ()
clearURIPassword :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIPassword URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIPasswordFieldInfo
instance AttrInfo URIPasswordFieldInfo where
type AttrBaseTypeConstraint URIPasswordFieldInfo = (~) URI
type AttrAllowedOps URIPasswordFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIPasswordFieldInfo = (~) CString
type AttrTransferTypeConstraint URIPasswordFieldInfo = (~)CString
type AttrTransferType URIPasswordFieldInfo = CString
type AttrGetType URIPasswordFieldInfo = Maybe T.Text
type AttrLabel URIPasswordFieldInfo = "password"
type AttrOrigin URIPasswordFieldInfo = URI
attrGet = getURIPassword
attrSet = setURIPassword
attrConstruct = undefined
attrClear = clearURIPassword
attrTransfer _ v = do
return v
uRI_password :: AttrLabelProxy "password"
uRI_password = AttrLabelProxy
#endif
getURIHost :: MonadIO m => URI -> m (Maybe T.Text)
getURIHost :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIHost URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIHost :: MonadIO m => URI -> CString -> m ()
setURIHost :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIHost URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
val :: CString)
clearURIHost :: MonadIO m => URI -> m ()
clearURIHost :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIHost URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIHostFieldInfo
instance AttrInfo URIHostFieldInfo where
type AttrBaseTypeConstraint URIHostFieldInfo = (~) URI
type AttrAllowedOps URIHostFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIHostFieldInfo = (~) CString
type AttrTransferTypeConstraint URIHostFieldInfo = (~)CString
type AttrTransferType URIHostFieldInfo = CString
type AttrGetType URIHostFieldInfo = Maybe T.Text
type AttrLabel URIHostFieldInfo = "host"
type AttrOrigin URIHostFieldInfo = URI
attrGet = getURIHost
attrSet = setURIHost
attrConstruct = undefined
attrClear = clearURIHost
attrTransfer _ v = do
return v
uRI_host :: AttrLabelProxy "host"
uRI_host = AttrLabelProxy
#endif
getURIPort :: MonadIO m => URI -> m Word32
getURIPort :: forall (m :: * -> *). MonadIO m => URI -> m Word32
getURIPort URI
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO Word32) -> IO Word32)
-> (Ptr URI -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setURIPort :: MonadIO m => URI -> Word32 -> m ()
setURIPort :: forall (m :: * -> *). MonadIO m => URI -> Word32 -> m ()
setURIPort URI
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data URIPortFieldInfo
instance AttrInfo URIPortFieldInfo where
type AttrBaseTypeConstraint URIPortFieldInfo = (~) URI
type AttrAllowedOps URIPortFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint URIPortFieldInfo = (~) Word32
type AttrTransferTypeConstraint URIPortFieldInfo = (~)Word32
type AttrTransferType URIPortFieldInfo = Word32
type AttrGetType URIPortFieldInfo = Word32
type AttrLabel URIPortFieldInfo = "port"
type AttrOrigin URIPortFieldInfo = URI
attrGet = getURIPort
attrSet = setURIPort
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
uRI_port :: AttrLabelProxy "port"
uRI_port = AttrLabelProxy
#endif
getURIPath :: MonadIO m => URI -> m (Maybe T.Text)
getURIPath :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIPath URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIPath :: MonadIO m => URI -> CString -> m ()
setURIPath :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIPath URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CString
val :: CString)
clearURIPath :: MonadIO m => URI -> m ()
clearURIPath :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIPath URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIPathFieldInfo
instance AttrInfo URIPathFieldInfo where
type AttrBaseTypeConstraint URIPathFieldInfo = (~) URI
type AttrAllowedOps URIPathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIPathFieldInfo = (~) CString
type AttrTransferTypeConstraint URIPathFieldInfo = (~)CString
type AttrTransferType URIPathFieldInfo = CString
type AttrGetType URIPathFieldInfo = Maybe T.Text
type AttrLabel URIPathFieldInfo = "path"
type AttrOrigin URIPathFieldInfo = URI
attrGet = getURIPath
attrSet = setURIPath
attrConstruct = undefined
attrClear = clearURIPath
attrTransfer _ v = do
return v
uRI_path :: AttrLabelProxy "path"
uRI_path = AttrLabelProxy
#endif
getURIQuery :: MonadIO m => URI -> m (Maybe T.Text)
getURIQuery :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIQuery URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIQuery :: MonadIO m => URI -> CString -> m ()
setURIQuery :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIQuery URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
val :: CString)
clearURIQuery :: MonadIO m => URI -> m ()
clearURIQuery :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIQuery URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIQueryFieldInfo
instance AttrInfo URIQueryFieldInfo where
type AttrBaseTypeConstraint URIQueryFieldInfo = (~) URI
type AttrAllowedOps URIQueryFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIQueryFieldInfo = (~) CString
type AttrTransferTypeConstraint URIQueryFieldInfo = (~)CString
type AttrTransferType URIQueryFieldInfo = CString
type AttrGetType URIQueryFieldInfo = Maybe T.Text
type AttrLabel URIQueryFieldInfo = "query"
type AttrOrigin URIQueryFieldInfo = URI
attrGet = getURIQuery
attrSet = setURIQuery
attrConstruct = undefined
attrClear = clearURIQuery
attrTransfer _ v = do
return v
uRI_query :: AttrLabelProxy "query"
uRI_query = AttrLabelProxy
#endif
getURIFragment :: MonadIO m => URI -> m (Maybe T.Text)
getURIFragment :: forall (m :: * -> *). MonadIO m => URI -> m (Maybe Text)
getURIFragment URI
s = 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
$ URI -> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr URI -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setURIFragment :: MonadIO m => URI -> CString -> m ()
setURIFragment :: forall (m :: * -> *). MonadIO m => URI -> CString -> m ()
setURIFragment URI
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (CString
val :: CString)
clearURIFragment :: MonadIO m => URI -> m ()
clearURIFragment :: forall (m :: * -> *). MonadIO m => URI -> m ()
clearURIFragment URI
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ URI -> (Ptr URI -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr URI
s ((Ptr URI -> IO ()) -> IO ()) -> (Ptr URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr URI
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr URI
ptr Ptr URI -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data URIFragmentFieldInfo
instance AttrInfo URIFragmentFieldInfo where
type AttrBaseTypeConstraint URIFragmentFieldInfo = (~) URI
type AttrAllowedOps URIFragmentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint URIFragmentFieldInfo = (~) CString
type AttrTransferTypeConstraint URIFragmentFieldInfo = (~)CString
type AttrTransferType URIFragmentFieldInfo = CString
type AttrGetType URIFragmentFieldInfo = Maybe T.Text
type AttrLabel URIFragmentFieldInfo = "fragment"
type AttrOrigin URIFragmentFieldInfo = URI
attrGet = getURIFragment
attrSet = setURIFragment
attrConstruct = undefined
attrClear = clearURIFragment
attrTransfer _ v = do
return v
uRI_fragment :: AttrLabelProxy "fragment"
uRI_fragment = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
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
foreign import ccall "soup_uri_new" soup_uri_new ::
CString ->
IO (Ptr URI)
uRINew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m (Maybe URI)
uRINew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m (Maybe URI)
uRINew Maybe Text
uriString = IO (Maybe URI) -> m (Maybe URI)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe URI) -> m (Maybe URI))
-> IO (Maybe URI) -> m (Maybe URI)
forall a b. (a -> b) -> a -> b
$ do
CString
maybeUriString <- case Maybe Text
uriString of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jUriString -> do
CString
jUriString' <- Text -> IO CString
textToCString Text
jUriString
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUriString'
Ptr URI
result <- CString -> IO (Ptr URI)
soup_uri_new CString
maybeUriString
Maybe URI
maybeResult <- Ptr URI -> (Ptr URI -> IO URI) -> IO (Maybe URI)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr URI
result ((Ptr URI -> IO URI) -> IO (Maybe URI))
-> (Ptr URI -> IO URI) -> IO (Maybe URI)
forall a b. (a -> b) -> a -> b
$ \Ptr URI
result' -> do
URI
result'' <- ((ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
URI) Ptr URI
result'
URI -> IO URI
forall (m :: * -> *) a. Monad m => a -> m a
return URI
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeUriString
Maybe URI -> IO (Maybe URI)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe URI
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_uri_new_with_base" soup_uri_new_with_base ::
Ptr URI ->
CString ->
IO (Ptr URI)
uRINewWithBase ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> T.Text
-> m URI
uRINewWithBase :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Text -> m URI
uRINewWithBase URI
base Text
uriString = IO URI -> m URI
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO URI -> m URI) -> IO URI -> m URI
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
base' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
base
CString
uriString' <- Text -> IO CString
textToCString Text
uriString
Ptr URI
result <- Ptr URI -> CString -> IO (Ptr URI)
soup_uri_new_with_base Ptr URI
base' CString
uriString'
Text -> Ptr URI -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRINewWithBase" Ptr URI
result
URI
result' <- ((ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
URI) Ptr URI
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
base
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
URI -> IO URI
forall (m :: * -> *) a. Monad m => a -> m a
return URI
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_uri_copy" soup_uri_copy ::
Ptr URI ->
IO (Ptr URI)
uRICopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m URI
uRICopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m URI
uRICopy URI
uri = IO URI -> m URI
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO URI -> m URI) -> IO URI -> m URI
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr URI
result <- Ptr URI -> IO (Ptr URI)
soup_uri_copy Ptr URI
uri'
Text -> Ptr URI -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRICopy" Ptr URI
result
URI
result' <- ((ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
URI) Ptr URI
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
URI -> IO URI
forall (m :: * -> *) a. Monad m => a -> m a
return URI
result'
#if defined(ENABLE_OVERLOADING)
data URICopyMethodInfo
instance (signature ~ (m URI), MonadIO m) => O.OverloadedMethod URICopyMethodInfo URI signature where
overloadedMethod = uRICopy
instance O.OverloadedMethodInfo URICopyMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRICopy",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRICopy"
}
#endif
foreign import ccall "soup_uri_copy_host" soup_uri_copy_host ::
Ptr URI ->
IO (Ptr URI)
uRICopyHost ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m URI
uRICopyHost :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m URI
uRICopyHost URI
uri = IO URI -> m URI
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO URI -> m URI) -> IO URI -> m URI
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr URI
result <- Ptr URI -> IO (Ptr URI)
soup_uri_copy_host Ptr URI
uri'
Text -> Ptr URI -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRICopyHost" Ptr URI
result
URI
result' <- ((ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
URI) Ptr URI
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
URI -> IO URI
forall (m :: * -> *) a. Monad m => a -> m a
return URI
result'
#if defined(ENABLE_OVERLOADING)
data URICopyHostMethodInfo
instance (signature ~ (m URI), MonadIO m) => O.OverloadedMethod URICopyHostMethodInfo URI signature where
overloadedMethod = uRICopyHost
instance O.OverloadedMethodInfo URICopyHostMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRICopyHost",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRICopyHost"
}
#endif
foreign import ccall "soup_uri_equal" soup_uri_equal ::
Ptr URI ->
Ptr URI ->
IO CInt
uRIEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> URI
-> m Bool
uRIEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> URI -> m Bool
uRIEqual URI
uri1 URI
uri2 = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
uri1' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri1
Ptr URI
uri2' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri2
CInt
result <- Ptr URI -> Ptr URI -> IO CInt
soup_uri_equal Ptr URI
uri1' Ptr URI
uri2'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri1
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri2
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data URIEqualMethodInfo
instance (signature ~ (URI -> m Bool), MonadIO m) => O.OverloadedMethod URIEqualMethodInfo URI signature where
overloadedMethod = uRIEqual
instance O.OverloadedMethodInfo URIEqualMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIEqual",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIEqual"
}
#endif
foreign import ccall "soup_uri_free" soup_uri_free ::
Ptr URI ->
IO ()
uRIFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m ()
uRIFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m ()
uRIFree URI
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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr URI -> IO ()
soup_uri_free Ptr URI
uri'
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URIFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod URIFreeMethodInfo URI signature where
overloadedMethod = uRIFree
instance O.OverloadedMethodInfo URIFreeMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIFree",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIFree"
}
#endif
foreign import ccall "soup_uri_get_fragment" soup_uri_get_fragment ::
Ptr URI ->
IO CString
uRIGetFragment ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetFragment :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetFragment URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_fragment Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetFragment" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetFragmentMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetFragmentMethodInfo URI signature where
overloadedMethod = uRIGetFragment
instance O.OverloadedMethodInfo URIGetFragmentMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetFragment",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetFragment"
}
#endif
foreign import ccall "soup_uri_get_host" soup_uri_get_host ::
Ptr URI ->
IO CString
uRIGetHost ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetHost :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetHost URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_host Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetHost" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetHostMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetHostMethodInfo URI signature where
overloadedMethod = uRIGetHost
instance O.OverloadedMethodInfo URIGetHostMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetHost",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetHost"
}
#endif
foreign import ccall "soup_uri_get_password" soup_uri_get_password ::
Ptr URI ->
IO CString
uRIGetPassword ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetPassword :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetPassword URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_password Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetPassword" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetPasswordMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetPasswordMethodInfo URI signature where
overloadedMethod = uRIGetPassword
instance O.OverloadedMethodInfo URIGetPasswordMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetPassword",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetPassword"
}
#endif
foreign import ccall "soup_uri_get_path" soup_uri_get_path ::
Ptr URI ->
IO CString
uRIGetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetPath :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetPath URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_path Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetPath" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetPathMethodInfo URI signature where
overloadedMethod = uRIGetPath
instance O.OverloadedMethodInfo URIGetPathMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetPath",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetPath"
}
#endif
foreign import ccall "soup_uri_get_port" soup_uri_get_port ::
Ptr URI ->
IO Word32
uRIGetPort ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m Word32
uRIGetPort :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Word32
uRIGetPort URI
uri = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Word32
result <- Ptr URI -> IO Word32
soup_uri_get_port Ptr URI
uri'
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data URIGetPortMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod URIGetPortMethodInfo URI signature where
overloadedMethod = uRIGetPort
instance O.OverloadedMethodInfo URIGetPortMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetPort",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetPort"
}
#endif
foreign import ccall "soup_uri_get_query" soup_uri_get_query ::
Ptr URI ->
IO CString
uRIGetQuery ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetQuery :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetQuery URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_query Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetQuery" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetQueryMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetQueryMethodInfo URI signature where
overloadedMethod = uRIGetQuery
instance O.OverloadedMethodInfo URIGetQueryMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetQuery",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetQuery"
}
#endif
foreign import ccall "soup_uri_get_scheme" soup_uri_get_scheme ::
Ptr URI ->
IO CString
uRIGetScheme ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetScheme :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetScheme URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_scheme Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetScheme" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetSchemeMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetSchemeMethodInfo URI signature where
overloadedMethod = uRIGetScheme
instance O.OverloadedMethodInfo URIGetSchemeMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetScheme",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetScheme"
}
#endif
foreign import ccall "soup_uri_get_user" soup_uri_get_user ::
Ptr URI ->
IO CString
uRIGetUser ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m T.Text
uRIGetUser :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Text
uRIGetUser URI
uri = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
result <- Ptr URI -> IO CString
soup_uri_get_user Ptr URI
uri'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIGetUser" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIGetUserMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod URIGetUserMethodInfo URI signature where
overloadedMethod = uRIGetUser
instance O.OverloadedMethodInfo URIGetUserMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIGetUser",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIGetUser"
}
#endif
foreign import ccall "soup_uri_host_equal" soup_uri_host_equal ::
Ptr URI ->
Ptr URI ->
IO CInt
uRIHostEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> URI
-> m Bool
uRIHostEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> URI -> m Bool
uRIHostEqual URI
v1 URI
v2 = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
v1' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
v1
Ptr URI
v2' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
v2
CInt
result <- Ptr URI -> Ptr URI -> IO CInt
soup_uri_host_equal Ptr URI
v1' Ptr URI
v2'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
v1
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
v2
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data URIHostEqualMethodInfo
instance (signature ~ (URI -> m Bool), MonadIO m) => O.OverloadedMethod URIHostEqualMethodInfo URI signature where
overloadedMethod = uRIHostEqual
instance O.OverloadedMethodInfo URIHostEqualMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIHostEqual",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIHostEqual"
}
#endif
foreign import ccall "soup_uri_host_hash" soup_uri_host_hash ::
Ptr URI ->
IO Word32
uRIHostHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m Word32
uRIHostHash :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Word32
uRIHostHash URI
key = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
key' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
key
Word32
result <- Ptr URI -> IO Word32
soup_uri_host_hash Ptr URI
key'
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
key
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data URIHostHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod URIHostHashMethodInfo URI signature where
overloadedMethod = uRIHostHash
instance O.OverloadedMethodInfo URIHostHashMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIHostHash",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIHostHash"
}
#endif
foreign import ccall "soup_uri_set_fragment" soup_uri_set_fragment ::
Ptr URI ->
CString ->
IO ()
uRISetFragment ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Maybe (T.Text)
-> m ()
uRISetFragment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Maybe Text -> m ()
uRISetFragment URI
uri Maybe Text
fragment = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
maybeFragment <- case Maybe Text
fragment of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jFragment -> do
CString
jFragment' <- Text -> IO CString
textToCString Text
jFragment
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFragment'
Ptr URI -> CString -> IO ()
soup_uri_set_fragment Ptr URI
uri' CString
maybeFragment
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFragment
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetFragmentMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod URISetFragmentMethodInfo URI signature where
overloadedMethod = uRISetFragment
instance O.OverloadedMethodInfo URISetFragmentMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetFragment",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetFragment"
}
#endif
foreign import ccall "soup_uri_set_host" soup_uri_set_host ::
Ptr URI ->
CString ->
IO ()
uRISetHost ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Maybe (T.Text)
-> m ()
uRISetHost :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Maybe Text -> m ()
uRISetHost URI
uri Maybe Text
host = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
maybeHost <- case Maybe Text
host of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jHost -> do
CString
jHost' <- Text -> IO CString
textToCString Text
jHost
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHost'
Ptr URI -> CString -> IO ()
soup_uri_set_host Ptr URI
uri' CString
maybeHost
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeHost
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetHostMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod URISetHostMethodInfo URI signature where
overloadedMethod = uRISetHost
instance O.OverloadedMethodInfo URISetHostMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetHost",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetHost"
}
#endif
foreign import ccall "soup_uri_set_password" soup_uri_set_password ::
Ptr URI ->
CString ->
IO ()
uRISetPassword ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Maybe (T.Text)
-> m ()
uRISetPassword :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Maybe Text -> m ()
uRISetPassword URI
uri Maybe Text
password = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
maybePassword <- case Maybe Text
password of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jPassword -> do
CString
jPassword' <- Text -> IO CString
textToCString Text
jPassword
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jPassword'
Ptr URI -> CString -> IO ()
soup_uri_set_password Ptr URI
uri' CString
maybePassword
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePassword
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetPasswordMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod URISetPasswordMethodInfo URI signature where
overloadedMethod = uRISetPassword
instance O.OverloadedMethodInfo URISetPasswordMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetPassword",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetPassword"
}
#endif
foreign import ccall "soup_uri_set_path" soup_uri_set_path ::
Ptr URI ->
CString ->
IO ()
uRISetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> T.Text
-> m ()
uRISetPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Text -> m ()
uRISetPath URI
uri Text
path = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr URI -> CString -> IO ()
soup_uri_set_path Ptr URI
uri' CString
path'
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod URISetPathMethodInfo URI signature where
overloadedMethod = uRISetPath
instance O.OverloadedMethodInfo URISetPathMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetPath",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetPath"
}
#endif
foreign import ccall "soup_uri_set_port" soup_uri_set_port ::
Ptr URI ->
Word32 ->
IO ()
uRISetPort ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Word32
-> m ()
uRISetPort :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Word32 -> m ()
uRISetPort URI
uri Word32
port = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr URI -> Word32 -> IO ()
soup_uri_set_port Ptr URI
uri' Word32
port
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetPortMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod URISetPortMethodInfo URI signature where
overloadedMethod = uRISetPort
instance O.OverloadedMethodInfo URISetPortMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetPort",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetPort"
}
#endif
foreign import ccall "soup_uri_set_query" soup_uri_set_query ::
Ptr URI ->
CString ->
IO ()
uRISetQuery ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Maybe (T.Text)
-> m ()
uRISetQuery :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Maybe Text -> m ()
uRISetQuery URI
uri Maybe Text
query = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
maybeQuery <- case Maybe Text
query of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jQuery -> do
CString
jQuery' <- Text -> IO CString
textToCString Text
jQuery
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jQuery'
Ptr URI -> CString -> IO ()
soup_uri_set_query Ptr URI
uri' CString
maybeQuery
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeQuery
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetQueryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod URISetQueryMethodInfo URI signature where
overloadedMethod = uRISetQuery
instance O.OverloadedMethodInfo URISetQueryMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetQuery",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetQuery"
}
#endif
foreign import ccall "soup_uri_set_query_from_form" soup_uri_set_query_from_form ::
Ptr URI ->
Ptr (GHashTable CString CString) ->
IO ()
uRISetQueryFromForm ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Map.Map T.Text T.Text
-> m ()
uRISetQueryFromForm :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Map Text Text -> m ()
uRISetQueryFromForm URI
uri Map Text Text
form = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
let form' :: [(Text, Text)]
form' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
form
[(CString, Text)]
form'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
form'
[(CString, CString)]
form''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
form''
let form'''' :: [(PtrWrapped CString, CString)]
form'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, CString)]
form'''
let form''''' :: [(PtrWrapped CString, PtrWrapped CString)]
form''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
cstringPackPtr [(PtrWrapped CString, CString)]
form''''
Ptr (GHashTable CString CString)
form'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
form'''''
Ptr URI -> Ptr (GHashTable CString CString) -> IO ()
soup_uri_set_query_from_form Ptr URI
uri' Ptr (GHashTable CString CString)
form''''''
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
form''''''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetQueryFromFormMethodInfo
instance (signature ~ (Map.Map T.Text T.Text -> m ()), MonadIO m) => O.OverloadedMethod URISetQueryFromFormMethodInfo URI signature where
overloadedMethod = uRISetQueryFromForm
instance O.OverloadedMethodInfo URISetQueryFromFormMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetQueryFromForm",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetQueryFromForm"
}
#endif
foreign import ccall "soup_uri_set_scheme" soup_uri_set_scheme ::
Ptr URI ->
CString ->
IO ()
uRISetScheme ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> T.Text
-> m ()
uRISetScheme :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Text -> m ()
uRISetScheme URI
uri Text
scheme = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
scheme' <- Text -> IO CString
textToCString Text
scheme
Ptr URI -> CString -> IO ()
soup_uri_set_scheme Ptr URI
uri' CString
scheme'
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
scheme'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetSchemeMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod URISetSchemeMethodInfo URI signature where
overloadedMethod = uRISetScheme
instance O.OverloadedMethodInfo URISetSchemeMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetScheme",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetScheme"
}
#endif
foreign import ccall "soup_uri_set_user" soup_uri_set_user ::
Ptr URI ->
CString ->
IO ()
uRISetUser ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Maybe (T.Text)
-> m ()
uRISetUser :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Maybe Text -> m ()
uRISetUser URI
uri Maybe Text
user = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CString
maybeUser <- case Maybe Text
user of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jUser -> do
CString
jUser' <- Text -> IO CString
textToCString Text
jUser
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUser'
Ptr URI -> CString -> IO ()
soup_uri_set_user Ptr URI
uri' CString
maybeUser
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeUser
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data URISetUserMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod URISetUserMethodInfo URI signature where
overloadedMethod = uRISetUser
instance O.OverloadedMethodInfo URISetUserMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRISetUser",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRISetUser"
}
#endif
foreign import ccall "soup_uri_to_string" soup_uri_to_string ::
Ptr URI ->
CInt ->
IO CString
uRIToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> Bool
-> m T.Text
uRIToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
URI -> Bool -> m Text
uRIToString URI
uri Bool
justPathAndQuery = 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 URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
let justPathAndQuery' :: CInt
justPathAndQuery' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
justPathAndQuery
CString
result <- Ptr URI -> CInt -> IO CString
soup_uri_to_string Ptr URI
uri' CInt
justPathAndQuery'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data URIToStringMethodInfo
instance (signature ~ (Bool -> m T.Text), MonadIO m) => O.OverloadedMethod URIToStringMethodInfo URI signature where
overloadedMethod = uRIToString
instance O.OverloadedMethodInfo URIToStringMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIToString",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIToString"
}
#endif
foreign import ccall "soup_uri_uses_default_port" soup_uri_uses_default_port ::
Ptr URI ->
IO CInt
uRIUsesDefaultPort ::
(B.CallStack.HasCallStack, MonadIO m) =>
URI
-> m Bool
uRIUsesDefaultPort :: forall (m :: * -> *). (HasCallStack, MonadIO m) => URI -> m Bool
uRIUsesDefaultPort URI
uri = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
CInt
result <- Ptr URI -> IO CInt
soup_uri_uses_default_port Ptr URI
uri'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data URIUsesDefaultPortMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod URIUsesDefaultPortMethodInfo URI signature where
overloadedMethod = uRIUsesDefaultPort
instance O.OverloadedMethodInfo URIUsesDefaultPortMethodInfo URI where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Soup.Structs.URI.uRIUsesDefaultPort",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Structs-URI.html#v:uRIUsesDefaultPort"
}
#endif
foreign import ccall "soup_uri_decode" soup_uri_decode ::
CString ->
IO CString
uRIDecode ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m T.Text
uRIDecode :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Text
uRIDecode Text
part = 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
CString
part' <- Text -> IO CString
textToCString Text
part
CString
result <- CString -> IO CString
soup_uri_decode CString
part'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIDecode" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
part'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_uri_encode" soup_uri_encode ::
CString ->
CString ->
IO CString
uRIEncode ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (T.Text)
-> m T.Text
uRIEncode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Maybe Text -> m Text
uRIEncode Text
part Maybe Text
escapeExtra = 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
CString
part' <- Text -> IO CString
textToCString Text
part
CString
maybeEscapeExtra <- case Maybe Text
escapeExtra of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jEscapeExtra -> do
CString
jEscapeExtra' <- Text -> IO CString
textToCString Text
jEscapeExtra
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jEscapeExtra'
CString
result <- CString -> CString -> IO CString
soup_uri_encode CString
part' CString
maybeEscapeExtra
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRIEncode" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
part'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeEscapeExtra
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_uri_normalize" soup_uri_normalize ::
CString ->
CString ->
IO CString
uRINormalize ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (T.Text)
-> m T.Text
uRINormalize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Maybe Text -> m Text
uRINormalize Text
part Maybe Text
unescapeExtra = 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
CString
part' <- Text -> IO CString
textToCString Text
part
CString
maybeUnescapeExtra <- case Maybe Text
unescapeExtra of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jUnescapeExtra -> do
CString
jUnescapeExtra' <- Text -> IO CString
textToCString Text
jUnescapeExtra
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUnescapeExtra'
CString
result <- CString -> CString -> IO CString
soup_uri_normalize CString
part' CString
maybeUnescapeExtra
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uRINormalize" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
part'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeUnescapeExtra
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
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 "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.OverloadedMethod info URI p) => OL.IsLabel t (URI -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveURIMethod t URI, O.OverloadedMethod info URI p, R.HasField t URI p) => R.HasField t URI p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveURIMethod t URI, O.OverloadedMethodInfo info URI) => OL.IsLabel t (O.MethodProxy info URI) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif