{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Uri
(
Uri(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveUriMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UriAppendPathMethodInfo ,
#endif
uriAppendPath ,
#if defined(ENABLE_OVERLOADING)
UriAppendPathSegmentMethodInfo ,
#endif
uriAppendPathSegment ,
uriConstruct ,
#if defined(ENABLE_OVERLOADING)
UriEqualMethodInfo ,
#endif
uriEqual ,
uriFromString ,
#if defined(ENABLE_OVERLOADING)
UriFromStringWithBaseMethodInfo ,
#endif
uriFromStringWithBase ,
#if defined(ENABLE_OVERLOADING)
UriGetFragmentMethodInfo ,
#endif
uriGetFragment ,
#if defined(ENABLE_OVERLOADING)
UriGetHostMethodInfo ,
#endif
uriGetHost ,
uriGetLocation ,
#if defined(ENABLE_OVERLOADING)
UriGetMediaFragmentTableMethodInfo ,
#endif
uriGetMediaFragmentTable ,
#if defined(ENABLE_OVERLOADING)
UriGetPathMethodInfo ,
#endif
uriGetPath ,
#if defined(ENABLE_OVERLOADING)
UriGetPathSegmentsMethodInfo ,
#endif
uriGetPathSegments ,
#if defined(ENABLE_OVERLOADING)
UriGetPathStringMethodInfo ,
#endif
uriGetPathString ,
#if defined(ENABLE_OVERLOADING)
UriGetPortMethodInfo ,
#endif
uriGetPort ,
uriGetProtocol ,
#if defined(ENABLE_OVERLOADING)
UriGetQueryKeysMethodInfo ,
#endif
uriGetQueryKeys ,
#if defined(ENABLE_OVERLOADING)
UriGetQueryStringMethodInfo ,
#endif
uriGetQueryString ,
#if defined(ENABLE_OVERLOADING)
UriGetQueryTableMethodInfo ,
#endif
uriGetQueryTable ,
#if defined(ENABLE_OVERLOADING)
UriGetQueryValueMethodInfo ,
#endif
uriGetQueryValue ,
#if defined(ENABLE_OVERLOADING)
UriGetSchemeMethodInfo ,
#endif
uriGetScheme ,
#if defined(ENABLE_OVERLOADING)
UriGetUserinfoMethodInfo ,
#endif
uriGetUserinfo ,
uriHasProtocol ,
#if defined(ENABLE_OVERLOADING)
UriIsNormalizedMethodInfo ,
#endif
uriIsNormalized ,
uriIsValid ,
#if defined(ENABLE_OVERLOADING)
UriIsWritableMethodInfo ,
#endif
uriIsWritable ,
#if defined(ENABLE_OVERLOADING)
UriJoinMethodInfo ,
#endif
uriJoin ,
uriJoinStrings ,
#if defined(ENABLE_OVERLOADING)
UriMakeWritableMethodInfo ,
#endif
uriMakeWritable ,
uriNew ,
#if defined(ENABLE_OVERLOADING)
UriNewWithBaseMethodInfo ,
#endif
uriNewWithBase ,
#if defined(ENABLE_OVERLOADING)
UriNormalizeMethodInfo ,
#endif
uriNormalize ,
uriProtocolIsSupported ,
uriProtocolIsValid ,
#if defined(ENABLE_OVERLOADING)
UriQueryHasKeyMethodInfo ,
#endif
uriQueryHasKey ,
#if defined(ENABLE_OVERLOADING)
UriRemoveQueryKeyMethodInfo ,
#endif
uriRemoveQueryKey ,
#if defined(ENABLE_OVERLOADING)
UriSetFragmentMethodInfo ,
#endif
uriSetFragment ,
#if defined(ENABLE_OVERLOADING)
UriSetHostMethodInfo ,
#endif
uriSetHost ,
#if defined(ENABLE_OVERLOADING)
UriSetPathMethodInfo ,
#endif
uriSetPath ,
#if defined(ENABLE_OVERLOADING)
UriSetPathSegmentsMethodInfo ,
#endif
uriSetPathSegments ,
#if defined(ENABLE_OVERLOADING)
UriSetPathStringMethodInfo ,
#endif
uriSetPathString ,
#if defined(ENABLE_OVERLOADING)
UriSetPortMethodInfo ,
#endif
uriSetPort ,
#if defined(ENABLE_OVERLOADING)
UriSetQueryStringMethodInfo ,
#endif
uriSetQueryString ,
#if defined(ENABLE_OVERLOADING)
UriSetQueryTableMethodInfo ,
#endif
uriSetQueryTable ,
#if defined(ENABLE_OVERLOADING)
UriSetQueryValueMethodInfo ,
#endif
uriSetQueryValue ,
#if defined(ENABLE_OVERLOADING)
UriSetSchemeMethodInfo ,
#endif
uriSetScheme ,
#if defined(ENABLE_OVERLOADING)
UriSetUserinfoMethodInfo ,
#endif
uriSetUserinfo ,
#if defined(ENABLE_OVERLOADING)
UriToStringMethodInfo ,
#endif
uriToString ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
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 "gst_uri_get_type" c_gst_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_gst_uri_get_type
instance B.Types.GBoxed Uri
instance B.GValue.IsGValue Uri where
toGValue :: Uri -> IO GValue
toGValue Uri
o = do
GType
gtype <- IO GType
c_gst_uri_get_type
Uri -> (Ptr Uri -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Uri
o (GType -> (GValue -> Ptr Uri -> IO ()) -> Ptr Uri -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Uri -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Uri
fromGValue GValue
gv = do
Ptr Uri
ptr <- GValue -> IO (Ptr Uri)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Uri)
(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
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Uri
type instance O.AttributeList Uri = UriAttributeList
type UriAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_uri_new" gst_uri_new ::
CString ->
CString ->
CString ->
Word32 ->
CString ->
CString ->
CString ->
IO (Ptr Uri)
uriNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Word32
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> m Uri
uriNew :: Maybe Text
-> Maybe Text
-> Maybe Text
-> Word32
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> m Uri
uriNew Maybe Text
scheme Maybe Text
userinfo Maybe Text
host Word32
port Maybe Text
path Maybe Text
query Maybe Text
fragment = 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 CChar
maybeScheme <- case Maybe Text
scheme of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jScheme -> do
Ptr CChar
jScheme' <- Text -> IO (Ptr CChar)
textToCString Text
jScheme
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jScheme'
Ptr CChar
maybeUserinfo <- case Maybe Text
userinfo of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jUserinfo -> do
Ptr CChar
jUserinfo' <- Text -> IO (Ptr CChar)
textToCString Text
jUserinfo
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jUserinfo'
Ptr CChar
maybeHost <- case Maybe Text
host of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jHost -> do
Ptr CChar
jHost' <- Text -> IO (Ptr CChar)
textToCString Text
jHost
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jHost'
Ptr CChar
maybePath <- case Maybe Text
path of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jPath -> do
Ptr CChar
jPath' <- Text -> IO (Ptr CChar)
textToCString Text
jPath
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPath'
Ptr CChar
maybeQuery <- case Maybe Text
query of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jQuery -> do
Ptr CChar
jQuery' <- Text -> IO (Ptr CChar)
textToCString Text
jQuery
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jQuery'
Ptr CChar
maybeFragment <- case Maybe Text
fragment of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jFragment -> do
Ptr CChar
jFragment' <- Text -> IO (Ptr CChar)
textToCString Text
jFragment
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jFragment'
Ptr Uri
result <- Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Word32
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> IO (Ptr Uri)
gst_uri_new Ptr CChar
maybeScheme Ptr CChar
maybeUserinfo Ptr CChar
maybeHost Word32
port Ptr CChar
maybePath Ptr CChar
maybeQuery Ptr CChar
maybeFragment
Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriNew" 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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeScheme
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeUserinfo
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeHost
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePath
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeQuery
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeFragment
Uri -> IO Uri
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_append_path" gst_uri_append_path ::
Ptr Uri ->
CString ->
IO CInt
uriAppendPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriAppendPath :: Uri -> Text -> m Bool
uriAppendPath Uri
uri Text
relativePath = 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
Ptr CChar
relativePath' <- Text -> IO (Ptr CChar)
textToCString Text
relativePath
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_append_path Ptr Uri
uri' Ptr CChar
relativePath'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
relativePath'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriAppendPathMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriAppendPathMethodInfo Uri signature where
overloadedMethod = uriAppendPath
#endif
foreign import ccall "gst_uri_append_path_segment" gst_uri_append_path_segment ::
Ptr Uri ->
CString ->
IO CInt
uriAppendPathSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriAppendPathSegment :: Uri -> Text -> m Bool
uriAppendPathSegment Uri
uri Text
pathSegment = 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
Ptr CChar
pathSegment' <- Text -> IO (Ptr CChar)
textToCString Text
pathSegment
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_append_path_segment Ptr Uri
uri' Ptr CChar
pathSegment'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
pathSegment'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriAppendPathSegmentMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriAppendPathSegmentMethodInfo Uri signature where
overloadedMethod = uriAppendPathSegment
#endif
foreign import ccall "gst_uri_equal" gst_uri_equal ::
Ptr Uri ->
Ptr Uri ->
IO CInt
uriEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Uri
-> m Bool
uriEqual :: Uri -> Uri -> m Bool
uriEqual Uri
first Uri
second = 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
first' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
first
Ptr Uri
second' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
second
CInt
result <- Ptr Uri -> Ptr Uri -> IO CInt
gst_uri_equal Ptr Uri
first' Ptr Uri
second'
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
first
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
second
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.MethodInfo UriEqualMethodInfo Uri signature where
overloadedMethod = uriEqual
#endif
foreign import ccall "gst_uri_from_string_with_base" gst_uri_from_string_with_base ::
Ptr Uri ->
CString ->
IO (Ptr Uri)
uriFromStringWithBase ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Uri
uriFromStringWithBase :: Uri -> Text -> m Uri
uriFromStringWithBase Uri
base Text
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
base' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
base
Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr Uri
result <- Ptr Uri -> Ptr CChar -> IO (Ptr Uri)
gst_uri_from_string_with_base Ptr Uri
base' Ptr CChar
uri'
Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriFromStringWithBase" 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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Uri -> IO Uri
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'
#if defined(ENABLE_OVERLOADING)
data UriFromStringWithBaseMethodInfo
instance (signature ~ (T.Text -> m Uri), MonadIO m) => O.MethodInfo UriFromStringWithBaseMethodInfo Uri signature where
overloadedMethod = uriFromStringWithBase
#endif
foreign import ccall "gst_uri_get_fragment" gst_uri_get_fragment ::
Ptr Uri ->
IO CString
uriGetFragment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetFragment :: Uri -> m (Maybe Text)
uriGetFragment Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_fragment Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetFragmentMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetFragmentMethodInfo Uri signature where
overloadedMethod = uriGetFragment
#endif
foreign import ccall "gst_uri_get_host" gst_uri_get_host ::
Ptr Uri ->
IO CString
uriGetHost ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetHost :: Uri -> m (Maybe Text)
uriGetHost Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_host Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetHostMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetHostMethodInfo Uri signature where
overloadedMethod = uriGetHost
#endif
foreign import ccall "gst_uri_get_media_fragment_table" gst_uri_get_media_fragment_table ::
Ptr Uri ->
IO (Ptr (GHashTable CString CString))
uriGetMediaFragmentTable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe (Map.Map T.Text T.Text))
uriGetMediaFragmentTable :: Uri -> m (Maybe (Map Text Text))
uriGetMediaFragmentTable Uri
uri = IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text)))
-> IO (Maybe (Map Text Text)) -> m (Maybe (Map Text 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
Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr Uri -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
gst_uri_get_media_fragment_table Ptr Uri
uri'
Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result ((Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result' -> do
[(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
let result''' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result''
[(Text, PtrWrapped (Ptr CChar))]
result'''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'''
let result''''' :: [(Text, Ptr CChar)]
result''''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result''''
[(Text, Text)]
result'''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result'''''
let result''''''' :: Map Text Text
result''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result''''''
Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
Map Text Text -> IO (Map Text Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map Text Text)
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetMediaFragmentTableMethodInfo
instance (signature ~ (m (Maybe (Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo UriGetMediaFragmentTableMethodInfo Uri signature where
overloadedMethod = uriGetMediaFragmentTable
#endif
foreign import ccall "gst_uri_get_path" gst_uri_get_path ::
Ptr Uri ->
IO CString
uriGetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetPath :: Uri -> m (Maybe Text)
uriGetPath Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_path Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetPathMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetPathMethodInfo Uri signature where
overloadedMethod = uriGetPath
#endif
foreign import ccall "gst_uri_get_path_segments" gst_uri_get_path_segments ::
Ptr Uri ->
IO (Ptr (GList CString))
uriGetPathSegments ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m [T.Text]
uriGetPathSegments :: Uri -> m [Text]
uriGetPathSegments 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
Ptr (GList (Ptr CChar))
result <- Ptr Uri -> IO (Ptr (GList (Ptr CChar)))
gst_uri_get_path_segments Ptr Uri
uri'
[Ptr CChar]
result' <- Ptr (GList (Ptr CChar)) -> IO [Ptr CChar]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr CChar))
result
[Text]
result'' <- (Ptr CChar -> IO Text) -> [Ptr CChar] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [Ptr CChar]
result'
(Ptr CChar -> IO ()) -> Ptr (GList (Ptr CChar)) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGList Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GList (Ptr CChar))
result
Ptr (GList (Ptr CChar)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr CChar))
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 UriGetPathSegmentsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.MethodInfo UriGetPathSegmentsMethodInfo Uri signature where
overloadedMethod = uriGetPathSegments
#endif
foreign import ccall "gst_uri_get_path_string" gst_uri_get_path_string ::
Ptr Uri ->
IO CString
uriGetPathString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetPathString :: Uri -> m (Maybe Text)
uriGetPathString Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_path_string Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetPathStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetPathStringMethodInfo Uri signature where
overloadedMethod = uriGetPathString
#endif
foreign import ccall "gst_uri_get_port" gst_uri_get_port ::
Ptr Uri ->
IO Word32
uriGetPort ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m Word32
uriGetPort :: 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
gst_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.MethodInfo UriGetPortMethodInfo Uri signature where
overloadedMethod = uriGetPort
#endif
foreign import ccall "gst_uri_get_query_keys" gst_uri_get_query_keys ::
Ptr Uri ->
IO (Ptr (GList CString))
uriGetQueryKeys ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m [T.Text]
uriGetQueryKeys :: Uri -> m [Text]
uriGetQueryKeys 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
Ptr (GList (Ptr CChar))
result <- Ptr Uri -> IO (Ptr (GList (Ptr CChar)))
gst_uri_get_query_keys Ptr Uri
uri'
[Ptr CChar]
result' <- Ptr (GList (Ptr CChar)) -> IO [Ptr CChar]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr CChar))
result
[Text]
result'' <- (Ptr CChar -> IO Text) -> [Ptr CChar] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [Ptr CChar]
result'
Ptr (GList (Ptr CChar)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr CChar))
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 UriGetQueryKeysMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.MethodInfo UriGetQueryKeysMethodInfo Uri signature where
overloadedMethod = uriGetQueryKeys
#endif
foreign import ccall "gst_uri_get_query_string" gst_uri_get_query_string ::
Ptr Uri ->
IO CString
uriGetQueryString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetQueryString :: Uri -> m (Maybe Text)
uriGetQueryString Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_query_string Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetQueryStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetQueryStringMethodInfo Uri signature where
overloadedMethod = uriGetQueryString
#endif
foreign import ccall "gst_uri_get_query_table" gst_uri_get_query_table ::
Ptr Uri ->
IO (Ptr (GHashTable CString CString))
uriGetQueryTable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe (Map.Map T.Text T.Text))
uriGetQueryTable :: Uri -> m (Maybe (Map Text Text))
uriGetQueryTable Uri
uri = IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text)))
-> IO (Maybe (Map Text Text)) -> m (Maybe (Map Text 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
Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr Uri -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
gst_uri_get_query_table Ptr Uri
uri'
Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result ((Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result' -> do
[(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
let result''' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result''
[(Text, PtrWrapped (Ptr CChar))]
result'''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'''
let result''''' :: [(Text, Ptr CChar)]
result''''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result''''
[(Text, Text)]
result'''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result'''''
let result''''''' :: Map Text Text
result''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result''''''
Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
Map Text Text -> IO (Map Text Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map Text Text)
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetQueryTableMethodInfo
instance (signature ~ (m (Maybe (Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo UriGetQueryTableMethodInfo Uri signature where
overloadedMethod = uriGetQueryTable
#endif
foreign import ccall "gst_uri_get_query_value" gst_uri_get_query_value ::
Ptr Uri ->
CString ->
IO CString
uriGetQueryValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m (Maybe T.Text)
uriGetQueryValue :: Uri -> Text -> m (Maybe Text)
uriGetQueryValue Uri
uri Text
queryKey = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
queryKey' <- Text -> IO (Ptr CChar)
textToCString Text
queryKey
Ptr CChar
result <- Ptr Uri -> Ptr CChar -> IO (Ptr CChar)
gst_uri_get_query_value Ptr Uri
uri' Ptr CChar
queryKey'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
queryKey'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetQueryValueMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetQueryValueMethodInfo Uri signature where
overloadedMethod = uriGetQueryValue
#endif
foreign import ccall "gst_uri_get_scheme" gst_uri_get_scheme ::
Ptr Uri ->
IO CString
uriGetScheme ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetScheme :: Uri -> m (Maybe Text)
uriGetScheme Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_scheme Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetSchemeMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetSchemeMethodInfo Uri signature where
overloadedMethod = uriGetScheme
#endif
foreign import ccall "gst_uri_get_userinfo" gst_uri_get_userinfo ::
Ptr Uri ->
IO CString
uriGetUserinfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m (Maybe T.Text)
uriGetUserinfo :: Uri -> m (Maybe Text)
uriGetUserinfo Uri
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_get_userinfo Ptr Uri
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriGetUserinfoMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo UriGetUserinfoMethodInfo Uri signature where
overloadedMethod = uriGetUserinfo
#endif
foreign import ccall "gst_uri_is_normalized" gst_uri_is_normalized ::
Ptr Uri ->
IO CInt
uriIsNormalized ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m Bool
uriIsNormalized :: Uri -> m Bool
uriIsNormalized 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
gst_uri_is_normalized 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 UriIsNormalizedMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UriIsNormalizedMethodInfo Uri signature where
overloadedMethod = uriIsNormalized
#endif
foreign import ccall "gst_uri_is_writable" gst_uri_is_writable ::
Ptr Uri ->
IO CInt
uriIsWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m Bool
uriIsWritable :: Uri -> m Bool
uriIsWritable 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
gst_uri_is_writable 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 UriIsWritableMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UriIsWritableMethodInfo Uri signature where
overloadedMethod = uriIsWritable
#endif
foreign import ccall "gst_uri_join" gst_uri_join ::
Ptr Uri ->
Ptr Uri ->
IO (Ptr Uri)
uriJoin ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Maybe (Uri)
-> m (Maybe Uri)
uriJoin :: Uri -> Maybe Uri -> m (Maybe Uri)
uriJoin Uri
baseUri Maybe Uri
refUri = 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
Ptr Uri
baseUri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
baseUri
Ptr Uri
maybeRefUri <- case Maybe Uri
refUri of
Maybe Uri
Nothing -> Ptr Uri -> IO (Ptr Uri)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Uri
forall a. Ptr a
nullPtr
Just Uri
jRefUri -> do
Ptr Uri
jRefUri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
jRefUri
Ptr Uri -> IO (Ptr Uri)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Uri
jRefUri'
Ptr Uri
result <- Ptr Uri -> Ptr Uri -> IO (Ptr Uri)
gst_uri_join Ptr Uri
baseUri' Ptr Uri
maybeRefUri
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''
Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
baseUri
Maybe Uri -> (Uri -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Uri
refUri Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Uri -> IO (Maybe Uri)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Uri
maybeResult
#if defined(ENABLE_OVERLOADING)
data UriJoinMethodInfo
instance (signature ~ (Maybe (Uri) -> m (Maybe Uri)), MonadIO m) => O.MethodInfo UriJoinMethodInfo Uri signature where
overloadedMethod = uriJoin
#endif
foreign import ccall "gst_uri_make_writable" gst_uri_make_writable ::
Ptr Uri ->
IO (Ptr Uri)
uriMakeWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m Uri
uriMakeWritable :: Uri -> m Uri
uriMakeWritable 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, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Uri
uri
Ptr Uri
result <- Ptr Uri -> IO (Ptr Uri)
gst_uri_make_writable Ptr Uri
uri'
Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriMakeWritable" 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 UriMakeWritableMethodInfo
instance (signature ~ (m Uri), MonadIO m) => O.MethodInfo UriMakeWritableMethodInfo Uri signature where
overloadedMethod = uriMakeWritable
#endif
foreign import ccall "gst_uri_new_with_base" gst_uri_new_with_base ::
Ptr Uri ->
CString ->
CString ->
CString ->
Word32 ->
CString ->
CString ->
CString ->
IO (Ptr Uri)
uriNewWithBase ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Word32
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> m Uri
uriNewWithBase :: Uri
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Word32
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> m Uri
uriNewWithBase Uri
base Maybe Text
scheme Maybe Text
userinfo Maybe Text
host Word32
port Maybe Text
path Maybe Text
query Maybe Text
fragment = 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
Ptr CChar
maybeScheme <- case Maybe Text
scheme of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jScheme -> do
Ptr CChar
jScheme' <- Text -> IO (Ptr CChar)
textToCString Text
jScheme
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jScheme'
Ptr CChar
maybeUserinfo <- case Maybe Text
userinfo of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jUserinfo -> do
Ptr CChar
jUserinfo' <- Text -> IO (Ptr CChar)
textToCString Text
jUserinfo
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jUserinfo'
Ptr CChar
maybeHost <- case Maybe Text
host of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jHost -> do
Ptr CChar
jHost' <- Text -> IO (Ptr CChar)
textToCString Text
jHost
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jHost'
Ptr CChar
maybePath <- case Maybe Text
path of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jPath -> do
Ptr CChar
jPath' <- Text -> IO (Ptr CChar)
textToCString Text
jPath
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPath'
Ptr CChar
maybeQuery <- case Maybe Text
query of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jQuery -> do
Ptr CChar
jQuery' <- Text -> IO (Ptr CChar)
textToCString Text
jQuery
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jQuery'
Ptr CChar
maybeFragment <- case Maybe Text
fragment of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jFragment -> do
Ptr CChar
jFragment' <- Text -> IO (Ptr CChar)
textToCString Text
jFragment
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jFragment'
Ptr Uri
result <- Ptr Uri
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Word32
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> IO (Ptr Uri)
gst_uri_new_with_base Ptr Uri
base' Ptr CChar
maybeScheme Ptr CChar
maybeUserinfo Ptr CChar
maybeHost Word32
port Ptr CChar
maybePath Ptr CChar
maybeQuery Ptr CChar
maybeFragment
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeScheme
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeUserinfo
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeHost
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePath
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeQuery
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeFragment
Uri -> IO Uri
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'
#if defined(ENABLE_OVERLOADING)
data UriNewWithBaseMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Word32 -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m Uri), MonadIO m) => O.MethodInfo UriNewWithBaseMethodInfo Uri signature where
overloadedMethod = uriNewWithBase
#endif
foreign import ccall "gst_uri_normalize" gst_uri_normalize ::
Ptr Uri ->
IO CInt
uriNormalize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m Bool
uriNormalize :: Uri -> m Bool
uriNormalize 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
gst_uri_normalize 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 UriNormalizeMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo UriNormalizeMethodInfo Uri signature where
overloadedMethod = uriNormalize
#endif
foreign import ccall "gst_uri_query_has_key" gst_uri_query_has_key ::
Ptr Uri ->
CString ->
IO CInt
uriQueryHasKey ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriQueryHasKey :: Uri -> Text -> m Bool
uriQueryHasKey Uri
uri Text
queryKey = 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
Ptr CChar
queryKey' <- Text -> IO (Ptr CChar)
textToCString Text
queryKey
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_query_has_key Ptr Uri
uri' Ptr CChar
queryKey'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
queryKey'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriQueryHasKeyMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriQueryHasKeyMethodInfo Uri signature where
overloadedMethod = uriQueryHasKey
#endif
foreign import ccall "gst_uri_remove_query_key" gst_uri_remove_query_key ::
Ptr Uri ->
CString ->
IO CInt
uriRemoveQueryKey ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriRemoveQueryKey :: Uri -> Text -> m Bool
uriRemoveQueryKey Uri
uri Text
queryKey = 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
Ptr CChar
queryKey' <- Text -> IO (Ptr CChar)
textToCString Text
queryKey
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_remove_query_key Ptr Uri
uri' Ptr CChar
queryKey'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
queryKey'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriRemoveQueryKeyMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriRemoveQueryKeyMethodInfo Uri signature where
overloadedMethod = uriRemoveQueryKey
#endif
foreign import ccall "gst_uri_set_fragment" gst_uri_set_fragment ::
Ptr Uri ->
CString ->
IO CInt
uriSetFragment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Maybe (T.Text)
-> m Bool
uriSetFragment :: Uri -> Maybe Text -> m Bool
uriSetFragment Uri
uri Maybe Text
fragment = 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
Ptr CChar
maybeFragment <- case Maybe Text
fragment of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jFragment -> do
Ptr CChar
jFragment' <- Text -> IO (Ptr CChar)
textToCString Text
jFragment
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jFragment'
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_fragment Ptr Uri
uri' Ptr CChar
maybeFragment
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeFragment
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetFragmentMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m) => O.MethodInfo UriSetFragmentMethodInfo Uri signature where
overloadedMethod = uriSetFragment
#endif
foreign import ccall "gst_uri_set_host" gst_uri_set_host ::
Ptr Uri ->
CString ->
IO CInt
uriSetHost ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetHost :: Uri -> Text -> m Bool
uriSetHost Uri
uri Text
host = 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
Ptr CChar
host' <- Text -> IO (Ptr CChar)
textToCString Text
host
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_host Ptr Uri
uri' Ptr CChar
host'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
host'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetHostMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetHostMethodInfo Uri signature where
overloadedMethod = uriSetHost
#endif
foreign import ccall "gst_uri_set_path" gst_uri_set_path ::
Ptr Uri ->
CString ->
IO CInt
uriSetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetPath :: Uri -> Text -> m Bool
uriSetPath Uri
uri Text
path = 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
Ptr CChar
path' <- Text -> IO (Ptr CChar)
textToCString Text
path
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_path Ptr Uri
uri' Ptr CChar
path'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
path'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetPathMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetPathMethodInfo Uri signature where
overloadedMethod = uriSetPath
#endif
foreign import ccall "gst_uri_set_path_segments" gst_uri_set_path_segments ::
Ptr Uri ->
Ptr (GList CString) ->
IO CInt
uriSetPathSegments ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> [T.Text]
-> m Bool
uriSetPathSegments :: Uri -> [Text] -> m Bool
uriSetPathSegments Uri
uri [Text]
pathSegments = 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
[Ptr CChar]
pathSegments' <- (Text -> IO (Ptr CChar)) -> [Text] -> IO [Ptr CChar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Text -> IO (Ptr CChar)
textToCString [Text]
pathSegments
Ptr (GList (Ptr CChar))
pathSegments'' <- [Ptr CChar] -> IO (Ptr (GList (Ptr CChar)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr CChar]
pathSegments'
CInt
result <- Ptr Uri -> Ptr (GList (Ptr CChar)) -> IO CInt
gst_uri_set_path_segments Ptr Uri
uri' Ptr (GList (Ptr CChar))
pathSegments''
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 UriSetPathSegmentsMethodInfo
instance (signature ~ ([T.Text] -> m Bool), MonadIO m) => O.MethodInfo UriSetPathSegmentsMethodInfo Uri signature where
overloadedMethod = uriSetPathSegments
#endif
foreign import ccall "gst_uri_set_path_string" gst_uri_set_path_string ::
Ptr Uri ->
CString ->
IO CInt
uriSetPathString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetPathString :: Uri -> Text -> m Bool
uriSetPathString Uri
uri Text
path = 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
Ptr CChar
path' <- Text -> IO (Ptr CChar)
textToCString Text
path
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_path_string Ptr Uri
uri' Ptr CChar
path'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
path'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetPathStringMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetPathStringMethodInfo Uri signature where
overloadedMethod = uriSetPathString
#endif
foreign import ccall "gst_uri_set_port" gst_uri_set_port ::
Ptr Uri ->
Word32 ->
IO CInt
uriSetPort ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Word32
-> m Bool
uriSetPort :: Uri -> Word32 -> m Bool
uriSetPort Uri
uri Word32
port = 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 -> Word32 -> IO CInt
gst_uri_set_port Ptr Uri
uri' Word32
port
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 UriSetPortMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo UriSetPortMethodInfo Uri signature where
overloadedMethod = uriSetPort
#endif
foreign import ccall "gst_uri_set_query_string" gst_uri_set_query_string ::
Ptr Uri ->
CString ->
IO CInt
uriSetQueryString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetQueryString :: Uri -> Text -> m Bool
uriSetQueryString Uri
uri Text
query = 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
Ptr CChar
query' <- Text -> IO (Ptr CChar)
textToCString Text
query
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_query_string Ptr Uri
uri' Ptr CChar
query'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
query'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetQueryStringMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetQueryStringMethodInfo Uri signature where
overloadedMethod = uriSetQueryString
#endif
foreign import ccall "gst_uri_set_query_table" gst_uri_set_query_table ::
Ptr Uri ->
Ptr (GHashTable CString CString) ->
IO CInt
uriSetQueryTable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> Maybe (Map.Map T.Text T.Text)
-> m Bool
uriSetQueryTable :: Uri -> Maybe (Map Text Text) -> m Bool
uriSetQueryTable Uri
uri Maybe (Map Text Text)
queryTable = 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
Ptr (GHashTable (Ptr CChar) (Ptr CChar))
maybeQueryTable <- case Maybe (Map Text Text)
queryTable of
Maybe (Map Text Text)
Nothing -> Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable (Ptr CChar) (Ptr CChar))
forall a. Ptr a
nullPtr
Just Map Text Text
jQueryTable -> do
let jQueryTable' :: [(Text, Text)]
jQueryTable' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
jQueryTable
[(Ptr CChar, Text)]
jQueryTable'' <- (Text -> IO (Ptr CChar))
-> [(Text, Text)] -> IO [(Ptr CChar, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO (Ptr CChar)
textToCString [(Text, Text)]
jQueryTable'
[(Ptr CChar, Ptr CChar)]
jQueryTable''' <- (Text -> IO (Ptr CChar))
-> [(Ptr CChar, Text)] -> IO [(Ptr CChar, Ptr CChar)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO (Ptr CChar)
textToCString [(Ptr CChar, Text)]
jQueryTable''
let jQueryTable'''' :: [(PtrWrapped (Ptr CChar), Ptr CChar)]
jQueryTable'''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(Ptr CChar, Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst Ptr CChar -> PtrWrapped (Ptr CChar)
cstringPackPtr [(Ptr CChar, Ptr CChar)]
jQueryTable'''
let jQueryTable''''' :: [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
jQueryTable''''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond Ptr CChar -> PtrWrapped (Ptr CChar)
cstringPackPtr [(PtrWrapped (Ptr CChar), Ptr CChar)]
jQueryTable''''
Ptr (GHashTable (Ptr CChar) (Ptr CChar))
jQueryTable'''''' <- GHashFunc (Ptr CChar)
-> GEqualFunc (Ptr CChar)
-> Maybe (GDestroyNotify (Ptr CChar))
-> Maybe (GDestroyNotify (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc (Ptr CChar)
gStrHash GEqualFunc (Ptr CChar)
gStrEqual (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
jQueryTable'''''
Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable (Ptr CChar) (Ptr CChar))
jQueryTable''''''
CInt
result <- Ptr Uri -> Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO CInt
gst_uri_set_query_table Ptr Uri
uri' Ptr (GHashTable (Ptr CChar) (Ptr CChar))
maybeQueryTable
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
Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
maybeQueryTable
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetQueryTableMethodInfo
instance (signature ~ (Maybe (Map.Map T.Text T.Text) -> m Bool), MonadIO m) => O.MethodInfo UriSetQueryTableMethodInfo Uri signature where
overloadedMethod = uriSetQueryTable
#endif
foreign import ccall "gst_uri_set_query_value" gst_uri_set_query_value ::
Ptr Uri ->
CString ->
CString ->
IO CInt
uriSetQueryValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> Maybe (T.Text)
-> m Bool
uriSetQueryValue :: Uri -> Text -> Maybe Text -> m Bool
uriSetQueryValue Uri
uri Text
queryKey Maybe Text
queryValue = 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
Ptr CChar
queryKey' <- Text -> IO (Ptr CChar)
textToCString Text
queryKey
Ptr CChar
maybeQueryValue <- case Maybe Text
queryValue of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jQueryValue -> do
Ptr CChar
jQueryValue' <- Text -> IO (Ptr CChar)
textToCString Text
jQueryValue
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jQueryValue'
CInt
result <- Ptr Uri -> Ptr CChar -> Ptr CChar -> IO CInt
gst_uri_set_query_value Ptr Uri
uri' Ptr CChar
queryKey' Ptr CChar
maybeQueryValue
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
queryKey'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeQueryValue
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetQueryValueMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m Bool), MonadIO m) => O.MethodInfo UriSetQueryValueMethodInfo Uri signature where
overloadedMethod = uriSetQueryValue
#endif
foreign import ccall "gst_uri_set_scheme" gst_uri_set_scheme ::
Ptr Uri ->
CString ->
IO CInt
uriSetScheme ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetScheme :: Uri -> Text -> m Bool
uriSetScheme Uri
uri Text
scheme = 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
Ptr CChar
scheme' <- Text -> IO (Ptr CChar)
textToCString Text
scheme
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_scheme Ptr Uri
uri' Ptr CChar
scheme'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
scheme'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetSchemeMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetSchemeMethodInfo Uri signature where
overloadedMethod = uriSetScheme
#endif
foreign import ccall "gst_uri_set_userinfo" gst_uri_set_userinfo ::
Ptr Uri ->
CString ->
IO CInt
uriSetUserinfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> T.Text
-> m Bool
uriSetUserinfo :: Uri -> Text -> m Bool
uriSetUserinfo Uri
uri Text
userinfo = 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
Ptr CChar
userinfo' <- Text -> IO (Ptr CChar)
textToCString Text
userinfo
CInt
result <- Ptr Uri -> Ptr CChar -> IO CInt
gst_uri_set_userinfo Ptr Uri
uri' Ptr CChar
userinfo'
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
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
userinfo'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UriSetUserinfoMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo UriSetUserinfoMethodInfo Uri signature where
overloadedMethod = uriSetUserinfo
#endif
foreign import ccall "gst_uri_to_string" gst_uri_to_string ::
Ptr Uri ->
IO CString
uriToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Uri
-> m T.Text
uriToString :: Uri -> m Text
uriToString 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
Ptr CChar
result <- Ptr Uri -> IO (Ptr CChar)
gst_uri_to_string Ptr Uri
uri'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriToString" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
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 ~ (m T.Text), MonadIO m) => O.MethodInfo UriToStringMethodInfo Uri signature where
overloadedMethod = uriToString
#endif
foreign import ccall "gst_uri_construct" gst_uri_construct ::
CString ->
CString ->
IO CString
{-# DEPRECATED uriConstruct ["Use GstURI instead."] #-}
uriConstruct ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m T.Text
uriConstruct :: Text -> Text -> m Text
uriConstruct Text
protocol Text
location = 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 CChar
protocol' <- Text -> IO (Ptr CChar)
textToCString Text
protocol
Ptr CChar
location' <- Text -> IO (Ptr CChar)
textToCString Text
location
Ptr CChar
result <- Ptr CChar -> Ptr CChar -> IO (Ptr CChar)
gst_uri_construct Ptr CChar
protocol' Ptr CChar
location'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriConstruct" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
protocol'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
location'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_from_string" gst_uri_from_string ::
CString ->
IO (Ptr Uri)
uriFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Uri)
uriFromString :: Text -> m (Maybe Uri)
uriFromString Text
uri = 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
Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr Uri
result <- Ptr CChar -> IO (Ptr Uri)
gst_uri_from_string Ptr CChar
uri'
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''
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
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 "gst_uri_get_location" gst_uri_get_location ::
CString ->
IO CString
uriGetLocation ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
uriGetLocation :: Text -> m (Maybe Text)
uriGetLocation Text
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr CChar
result <- Ptr CChar -> IO (Ptr CChar)
gst_uri_get_location Ptr CChar
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_get_protocol" gst_uri_get_protocol ::
CString ->
IO CString
uriGetProtocol ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe T.Text)
uriGetProtocol :: Text -> m (Maybe Text)
uriGetProtocol Text
uri = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr CChar
result <- Ptr CChar -> IO (Ptr CChar)
gst_uri_get_protocol Ptr CChar
uri'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_has_protocol" gst_uri_has_protocol ::
CString ->
CString ->
IO CInt
uriHasProtocol ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Bool
uriHasProtocol :: Text -> Text -> m Bool
uriHasProtocol Text
uri Text
protocol = 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 CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr CChar
protocol' <- Text -> IO (Ptr CChar)
textToCString Text
protocol
CInt
result <- Ptr CChar -> Ptr CChar -> IO CInt
gst_uri_has_protocol Ptr CChar
uri' Ptr CChar
protocol'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
protocol'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_is_valid" gst_uri_is_valid ::
CString ->
IO CInt
uriIsValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
uriIsValid :: Text -> m Bool
uriIsValid Text
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 CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
CInt
result <- Ptr CChar -> IO CInt
gst_uri_is_valid Ptr CChar
uri'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_join_strings" gst_uri_join_strings ::
CString ->
CString ->
IO CString
uriJoinStrings ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m T.Text
uriJoinStrings :: Text -> Text -> m Text
uriJoinStrings Text
baseUri Text
refUri = 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 CChar
baseUri' <- Text -> IO (Ptr CChar)
textToCString Text
baseUri
Ptr CChar
refUri' <- Text -> IO (Ptr CChar)
textToCString Text
refUri
Ptr CChar
result <- Ptr CChar -> Ptr CChar -> IO (Ptr CChar)
gst_uri_join_strings Ptr CChar
baseUri' Ptr CChar
refUri'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriJoinStrings" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
baseUri'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
refUri'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_protocol_is_supported" gst_uri_protocol_is_supported ::
CUInt ->
CString ->
IO CInt
uriProtocolIsSupported ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.URIType
-> T.Text
-> m Bool
uriProtocolIsSupported :: URIType -> Text -> m Bool
uriProtocolIsSupported URIType
type_ Text
protocol = 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
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (URIType -> Int) -> URIType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URIType -> Int
forall a. Enum a => a -> Int
fromEnum) URIType
type_
Ptr CChar
protocol' <- Text -> IO (Ptr CChar)
textToCString Text
protocol
CInt
result <- CUInt -> Ptr CChar -> IO CInt
gst_uri_protocol_is_supported CUInt
type_' Ptr CChar
protocol'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
protocol'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_uri_protocol_is_valid" gst_uri_protocol_is_valid ::
CString ->
IO CInt
uriProtocolIsValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
uriProtocolIsValid :: Text -> m Bool
uriProtocolIsValid Text
protocol = 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 CChar
protocol' <- Text -> IO (Ptr CChar)
textToCString Text
protocol
CInt
result <- Ptr CChar -> IO CInt
gst_uri_protocol_is_valid Ptr CChar
protocol'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
protocol'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveUriMethod (t :: Symbol) (o :: *) :: * where
ResolveUriMethod "appendPath" o = UriAppendPathMethodInfo
ResolveUriMethod "appendPathSegment" o = UriAppendPathSegmentMethodInfo
ResolveUriMethod "equal" o = UriEqualMethodInfo
ResolveUriMethod "fromStringWithBase" o = UriFromStringWithBaseMethodInfo
ResolveUriMethod "isNormalized" o = UriIsNormalizedMethodInfo
ResolveUriMethod "isWritable" o = UriIsWritableMethodInfo
ResolveUriMethod "join" o = UriJoinMethodInfo
ResolveUriMethod "makeWritable" o = UriMakeWritableMethodInfo
ResolveUriMethod "newWithBase" o = UriNewWithBaseMethodInfo
ResolveUriMethod "normalize" o = UriNormalizeMethodInfo
ResolveUriMethod "queryHasKey" o = UriQueryHasKeyMethodInfo
ResolveUriMethod "removeQueryKey" o = UriRemoveQueryKeyMethodInfo
ResolveUriMethod "toString" o = UriToStringMethodInfo
ResolveUriMethod "getFragment" o = UriGetFragmentMethodInfo
ResolveUriMethod "getHost" o = UriGetHostMethodInfo
ResolveUriMethod "getMediaFragmentTable" o = UriGetMediaFragmentTableMethodInfo
ResolveUriMethod "getPath" o = UriGetPathMethodInfo
ResolveUriMethod "getPathSegments" o = UriGetPathSegmentsMethodInfo
ResolveUriMethod "getPathString" o = UriGetPathStringMethodInfo
ResolveUriMethod "getPort" o = UriGetPortMethodInfo
ResolveUriMethod "getQueryKeys" o = UriGetQueryKeysMethodInfo
ResolveUriMethod "getQueryString" o = UriGetQueryStringMethodInfo
ResolveUriMethod "getQueryTable" o = UriGetQueryTableMethodInfo
ResolveUriMethod "getQueryValue" o = UriGetQueryValueMethodInfo
ResolveUriMethod "getScheme" o = UriGetSchemeMethodInfo
ResolveUriMethod "getUserinfo" o = UriGetUserinfoMethodInfo
ResolveUriMethod "setFragment" o = UriSetFragmentMethodInfo
ResolveUriMethod "setHost" o = UriSetHostMethodInfo
ResolveUriMethod "setPath" o = UriSetPathMethodInfo
ResolveUriMethod "setPathSegments" o = UriSetPathSegmentsMethodInfo
ResolveUriMethod "setPathString" o = UriSetPathStringMethodInfo
ResolveUriMethod "setPort" o = UriSetPortMethodInfo
ResolveUriMethod "setQueryString" o = UriSetQueryStringMethodInfo
ResolveUriMethod "setQueryTable" o = UriSetQueryTableMethodInfo
ResolveUriMethod "setQueryValue" o = UriSetQueryValueMethodInfo
ResolveUriMethod "setScheme" o = UriSetSchemeMethodInfo
ResolveUriMethod "setUserinfo" o = UriSetUserinfoMethodInfo
ResolveUriMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUriMethod t Uri, O.MethodInfo 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
#endif