{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.WebKit2.Structs.MimeInfo
(
MimeInfo(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveMimeInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MimeInfoGetDescriptionMethodInfo ,
#endif
mimeInfoGetDescription ,
#if defined(ENABLE_OVERLOADING)
MimeInfoGetExtensionsMethodInfo ,
#endif
mimeInfoGetExtensions ,
#if defined(ENABLE_OVERLOADING)
MimeInfoGetMimeTypeMethodInfo ,
#endif
mimeInfoGetMimeType ,
#if defined(ENABLE_OVERLOADING)
MimeInfoRefMethodInfo ,
#endif
mimeInfoRef ,
#if defined(ENABLE_OVERLOADING)
MimeInfoUnrefMethodInfo ,
#endif
mimeInfoUnref ,
) 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 MimeInfo = MimeInfo (SP.ManagedPtr MimeInfo)
deriving (MimeInfo -> MimeInfo -> Bool
(MimeInfo -> MimeInfo -> Bool)
-> (MimeInfo -> MimeInfo -> Bool) -> Eq MimeInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MimeInfo -> MimeInfo -> Bool
$c/= :: MimeInfo -> MimeInfo -> Bool
== :: MimeInfo -> MimeInfo -> Bool
$c== :: MimeInfo -> MimeInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype MimeInfo where
toManagedPtr :: MimeInfo -> ManagedPtr MimeInfo
toManagedPtr (MimeInfo ManagedPtr MimeInfo
p) = ManagedPtr MimeInfo
p
foreign import ccall "webkit_mime_info_get_type" c_webkit_mime_info_get_type ::
IO GType
type instance O.ParentTypes MimeInfo = '[]
instance O.HasParentTypes MimeInfo
instance B.Types.TypedObject MimeInfo where
glibType :: IO GType
glibType = IO GType
c_webkit_mime_info_get_type
instance B.Types.GBoxed MimeInfo
instance B.GValue.IsGValue (Maybe MimeInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_mime_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe MimeInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MimeInfo
P.Nothing = Ptr GValue -> Ptr MimeInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr MimeInfo
forall a. Ptr a
FP.nullPtr :: FP.Ptr MimeInfo)
gvalueSet_ Ptr GValue
gv (P.Just MimeInfo
obj) = MimeInfo -> (Ptr MimeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MimeInfo
obj (Ptr GValue -> Ptr MimeInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MimeInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr MimeInfo
ptr <- Ptr GValue -> IO (Ptr MimeInfo)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr MimeInfo)
if Ptr MimeInfo
ptr Ptr MimeInfo -> Ptr MimeInfo -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MimeInfo
forall a. Ptr a
FP.nullPtr
then MimeInfo -> Maybe MimeInfo
forall a. a -> Maybe a
P.Just (MimeInfo -> Maybe MimeInfo) -> IO MimeInfo -> IO (Maybe MimeInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr MimeInfo -> MimeInfo) -> Ptr MimeInfo -> IO MimeInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr MimeInfo -> MimeInfo
MimeInfo Ptr MimeInfo
ptr
else Maybe MimeInfo -> IO (Maybe MimeInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MimeInfo
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MimeInfo
type instance O.AttributeList MimeInfo = MimeInfoAttributeList
type MimeInfoAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "webkit_mime_info_get_description" webkit_mime_info_get_description ::
Ptr MimeInfo ->
IO CString
mimeInfoGetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
MimeInfo
-> m T.Text
mimeInfoGetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MimeInfo -> m Text
mimeInfoGetDescription MimeInfo
info = 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 MimeInfo
info' <- MimeInfo -> IO (Ptr MimeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MimeInfo
info
CString
result <- Ptr MimeInfo -> IO CString
webkit_mime_info_get_description Ptr MimeInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mimeInfoGetDescription" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
MimeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MimeInfo
info
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data MimeInfoGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod MimeInfoGetDescriptionMethodInfo MimeInfo signature where
overloadedMethod = mimeInfoGetDescription
instance O.OverloadedMethodInfo MimeInfoGetDescriptionMethodInfo MimeInfo where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.WebKit2.Structs.MimeInfo.mimeInfoGetDescription",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Structs-MimeInfo.html#v:mimeInfoGetDescription"
}
#endif
foreign import ccall "webkit_mime_info_get_extensions" webkit_mime_info_get_extensions ::
Ptr MimeInfo ->
IO (Ptr CString)
mimeInfoGetExtensions ::
(B.CallStack.HasCallStack, MonadIO m) =>
MimeInfo
-> m [T.Text]
mimeInfoGetExtensions :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MimeInfo -> m [Text]
mimeInfoGetExtensions MimeInfo
info = 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 MimeInfo
info' <- MimeInfo -> IO (Ptr MimeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MimeInfo
info
Ptr CString
result <- Ptr MimeInfo -> IO (Ptr CString)
webkit_mime_info_get_extensions Ptr MimeInfo
info'
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mimeInfoGetExtensions" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
MimeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MimeInfo
info
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data MimeInfoGetExtensionsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.OverloadedMethod MimeInfoGetExtensionsMethodInfo MimeInfo signature where
overloadedMethod = mimeInfoGetExtensions
instance O.OverloadedMethodInfo MimeInfoGetExtensionsMethodInfo MimeInfo where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.WebKit2.Structs.MimeInfo.mimeInfoGetExtensions",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Structs-MimeInfo.html#v:mimeInfoGetExtensions"
}
#endif
foreign import ccall "webkit_mime_info_get_mime_type" webkit_mime_info_get_mime_type ::
Ptr MimeInfo ->
IO CString
mimeInfoGetMimeType ::
(B.CallStack.HasCallStack, MonadIO m) =>
MimeInfo
-> m T.Text
mimeInfoGetMimeType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MimeInfo -> m Text
mimeInfoGetMimeType MimeInfo
info = 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 MimeInfo
info' <- MimeInfo -> IO (Ptr MimeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MimeInfo
info
CString
result <- Ptr MimeInfo -> IO CString
webkit_mime_info_get_mime_type Ptr MimeInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mimeInfoGetMimeType" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
MimeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MimeInfo
info
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data MimeInfoGetMimeTypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod MimeInfoGetMimeTypeMethodInfo MimeInfo signature where
overloadedMethod = mimeInfoGetMimeType
instance O.OverloadedMethodInfo MimeInfoGetMimeTypeMethodInfo MimeInfo where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.WebKit2.Structs.MimeInfo.mimeInfoGetMimeType",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Structs-MimeInfo.html#v:mimeInfoGetMimeType"
}
#endif
foreign import ccall "webkit_mime_info_ref" webkit_mime_info_ref ::
Ptr MimeInfo ->
IO (Ptr MimeInfo)
mimeInfoRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
MimeInfo
-> m MimeInfo
mimeInfoRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MimeInfo -> m MimeInfo
mimeInfoRef MimeInfo
info = IO MimeInfo -> m MimeInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MimeInfo -> m MimeInfo) -> IO MimeInfo -> m MimeInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr MimeInfo
info' <- MimeInfo -> IO (Ptr MimeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MimeInfo
info
Ptr MimeInfo
result <- Ptr MimeInfo -> IO (Ptr MimeInfo)
webkit_mime_info_ref Ptr MimeInfo
info'
Text -> Ptr MimeInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"mimeInfoRef" Ptr MimeInfo
result
MimeInfo
result' <- ((ManagedPtr MimeInfo -> MimeInfo) -> Ptr MimeInfo -> IO MimeInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MimeInfo -> MimeInfo
MimeInfo) Ptr MimeInfo
result
MimeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MimeInfo
info
MimeInfo -> IO MimeInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MimeInfo
result'
#if defined(ENABLE_OVERLOADING)
data MimeInfoRefMethodInfo
instance (signature ~ (m MimeInfo), MonadIO m) => O.OverloadedMethod MimeInfoRefMethodInfo MimeInfo signature where
overloadedMethod = mimeInfoRef
instance O.OverloadedMethodInfo MimeInfoRefMethodInfo MimeInfo where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.WebKit2.Structs.MimeInfo.mimeInfoRef",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Structs-MimeInfo.html#v:mimeInfoRef"
}
#endif
foreign import ccall "webkit_mime_info_unref" webkit_mime_info_unref ::
Ptr MimeInfo ->
IO ()
mimeInfoUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
MimeInfo
-> m ()
mimeInfoUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => MimeInfo -> m ()
mimeInfoUnref MimeInfo
info = 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 MimeInfo
info' <- MimeInfo -> IO (Ptr MimeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MimeInfo
info
Ptr MimeInfo -> IO ()
webkit_mime_info_unref Ptr MimeInfo
info'
MimeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MimeInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MimeInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MimeInfoUnrefMethodInfo MimeInfo signature where
overloadedMethod = mimeInfoUnref
instance O.OverloadedMethodInfo MimeInfoUnrefMethodInfo MimeInfo where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.WebKit2.Structs.MimeInfo.mimeInfoUnref",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Structs-MimeInfo.html#v:mimeInfoUnref"
}
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMimeInfoMethod (t :: Symbol) (o :: *) :: * where
ResolveMimeInfoMethod "ref" o = MimeInfoRefMethodInfo
ResolveMimeInfoMethod "unref" o = MimeInfoUnrefMethodInfo
ResolveMimeInfoMethod "getDescription" o = MimeInfoGetDescriptionMethodInfo
ResolveMimeInfoMethod "getExtensions" o = MimeInfoGetExtensionsMethodInfo
ResolveMimeInfoMethod "getMimeType" o = MimeInfoGetMimeTypeMethodInfo
ResolveMimeInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMimeInfoMethod t MimeInfo, O.OverloadedMethod info MimeInfo p) => OL.IsLabel t (MimeInfo -> 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 ~ ResolveMimeInfoMethod t MimeInfo, O.OverloadedMethod info MimeInfo p, R.HasField t MimeInfo p) => R.HasField t MimeInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMimeInfoMethod t MimeInfo, O.OverloadedMethodInfo info MimeInfo) => OL.IsLabel t (O.MethodProxy info MimeInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif