{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Objects.ContentSniffer
(
ContentSniffer(..) ,
IsContentSniffer ,
toContentSniffer ,
#if defined(ENABLE_OVERLOADING)
ResolveContentSnifferMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ContentSnifferGetBufferSizeMethodInfo ,
#endif
contentSnifferGetBufferSize ,
contentSnifferNew ,
#if defined(ENABLE_OVERLOADING)
ContentSnifferSniffMethodInfo ,
#endif
contentSnifferSniff ,
) 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.Coerce as Coerce
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
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Structs.Buffer as Soup.Buffer
newtype ContentSniffer = ContentSniffer (SP.ManagedPtr ContentSniffer)
deriving (ContentSniffer -> ContentSniffer -> Bool
(ContentSniffer -> ContentSniffer -> Bool)
-> (ContentSniffer -> ContentSniffer -> Bool) -> Eq ContentSniffer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContentSniffer -> ContentSniffer -> Bool
$c/= :: ContentSniffer -> ContentSniffer -> Bool
== :: ContentSniffer -> ContentSniffer -> Bool
$c== :: ContentSniffer -> ContentSniffer -> Bool
Eq)
instance SP.ManagedPtrNewtype ContentSniffer where
toManagedPtr :: ContentSniffer -> ManagedPtr ContentSniffer
toManagedPtr (ContentSniffer ManagedPtr ContentSniffer
p) = ManagedPtr ContentSniffer
p
foreign import ccall "soup_content_sniffer_get_type"
c_soup_content_sniffer_get_type :: IO B.Types.GType
instance B.Types.TypedObject ContentSniffer where
glibType :: IO GType
glibType = IO GType
c_soup_content_sniffer_get_type
instance B.Types.GObject ContentSniffer
class (SP.GObject o, O.IsDescendantOf ContentSniffer o) => IsContentSniffer o
instance (SP.GObject o, O.IsDescendantOf ContentSniffer o) => IsContentSniffer o
instance O.HasParentTypes ContentSniffer
type instance O.ParentTypes ContentSniffer = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature]
toContentSniffer :: (MIO.MonadIO m, IsContentSniffer o) => o -> m ContentSniffer
toContentSniffer :: forall (m :: * -> *) o.
(MonadIO m, IsContentSniffer o) =>
o -> m ContentSniffer
toContentSniffer = IO ContentSniffer -> m ContentSniffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ContentSniffer -> m ContentSniffer)
-> (o -> IO ContentSniffer) -> o -> m ContentSniffer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ContentSniffer -> ContentSniffer)
-> o -> IO ContentSniffer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ContentSniffer -> ContentSniffer
ContentSniffer
instance B.GValue.IsGValue (Maybe ContentSniffer) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_content_sniffer_get_type
gvalueSet_ :: Ptr GValue -> Maybe ContentSniffer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ContentSniffer
P.Nothing = Ptr GValue -> Ptr ContentSniffer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ContentSniffer
forall a. Ptr a
FP.nullPtr :: FP.Ptr ContentSniffer)
gvalueSet_ Ptr GValue
gv (P.Just ContentSniffer
obj) = ContentSniffer -> (Ptr ContentSniffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContentSniffer
obj (Ptr GValue -> Ptr ContentSniffer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ContentSniffer)
gvalueGet_ Ptr GValue
gv = do
Ptr ContentSniffer
ptr <- Ptr GValue -> IO (Ptr ContentSniffer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ContentSniffer)
if Ptr ContentSniffer
ptr Ptr ContentSniffer -> Ptr ContentSniffer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ContentSniffer
forall a. Ptr a
FP.nullPtr
then ContentSniffer -> Maybe ContentSniffer
forall a. a -> Maybe a
P.Just (ContentSniffer -> Maybe ContentSniffer)
-> IO ContentSniffer -> IO (Maybe ContentSniffer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ContentSniffer -> ContentSniffer)
-> Ptr ContentSniffer -> IO ContentSniffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ContentSniffer -> ContentSniffer
ContentSniffer Ptr ContentSniffer
ptr
else Maybe ContentSniffer -> IO (Maybe ContentSniffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContentSniffer
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveContentSnifferMethod (t :: Symbol) (o :: *) :: * where
ResolveContentSnifferMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
ResolveContentSnifferMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
ResolveContentSnifferMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveContentSnifferMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveContentSnifferMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
ResolveContentSnifferMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveContentSnifferMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveContentSnifferMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveContentSnifferMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
ResolveContentSnifferMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveContentSnifferMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveContentSnifferMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveContentSnifferMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveContentSnifferMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveContentSnifferMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
ResolveContentSnifferMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveContentSnifferMethod "sniff" o = ContentSnifferSniffMethodInfo
ResolveContentSnifferMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveContentSnifferMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveContentSnifferMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveContentSnifferMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveContentSnifferMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveContentSnifferMethod "getBufferSize" o = ContentSnifferGetBufferSizeMethodInfo
ResolveContentSnifferMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveContentSnifferMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveContentSnifferMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveContentSnifferMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveContentSnifferMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveContentSnifferMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveContentSnifferMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveContentSnifferMethod t ContentSniffer, O.OverloadedMethod info ContentSniffer p) => OL.IsLabel t (ContentSniffer -> 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 ~ ResolveContentSnifferMethod t ContentSniffer, O.OverloadedMethod info ContentSniffer p, R.HasField t ContentSniffer p) => R.HasField t ContentSniffer p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveContentSnifferMethod t ContentSniffer, O.OverloadedMethodInfo info ContentSniffer) => OL.IsLabel t (O.MethodProxy info ContentSniffer) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContentSniffer
type instance O.AttributeList ContentSniffer = ContentSnifferAttributeList
type ContentSnifferAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ContentSniffer = ContentSnifferSignalList
type ContentSnifferSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_content_sniffer_new" soup_content_sniffer_new ::
IO (Ptr ContentSniffer)
contentSnifferNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ContentSniffer
contentSnifferNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ContentSniffer
contentSnifferNew = IO ContentSniffer -> m ContentSniffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ContentSniffer -> m ContentSniffer)
-> IO ContentSniffer -> m ContentSniffer
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSniffer
result <- IO (Ptr ContentSniffer)
soup_content_sniffer_new
Text -> Ptr ContentSniffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSnifferNew" Ptr ContentSniffer
result
ContentSniffer
result' <- ((ManagedPtr ContentSniffer -> ContentSniffer)
-> Ptr ContentSniffer -> IO ContentSniffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ContentSniffer -> ContentSniffer
ContentSniffer) Ptr ContentSniffer
result
ContentSniffer -> IO ContentSniffer
forall (m :: * -> *) a. Monad m => a -> m a
return ContentSniffer
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_content_sniffer_get_buffer_size" soup_content_sniffer_get_buffer_size ::
Ptr ContentSniffer ->
IO Word64
contentSnifferGetBufferSize ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSniffer a) =>
a
-> m Word64
contentSnifferGetBufferSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSniffer a) =>
a -> m Word64
contentSnifferGetBufferSize a
sniffer = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSniffer
sniffer' <- a -> IO (Ptr ContentSniffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sniffer
Word64
result <- Ptr ContentSniffer -> IO Word64
soup_content_sniffer_get_buffer_size Ptr ContentSniffer
sniffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sniffer
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data ContentSnifferGetBufferSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsContentSniffer a) => O.OverloadedMethod ContentSnifferGetBufferSizeMethodInfo a signature where
overloadedMethod = contentSnifferGetBufferSize
instance O.OverloadedMethodInfo ContentSnifferGetBufferSizeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Objects.ContentSniffer.contentSnifferGetBufferSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Objects-ContentSniffer.html#v:contentSnifferGetBufferSize"
})
#endif
foreign import ccall "soup_content_sniffer_sniff" soup_content_sniffer_sniff ::
Ptr ContentSniffer ->
Ptr Soup.Message.Message ->
Ptr Soup.Buffer.Buffer ->
Ptr (Ptr (GHashTable CString CString)) ->
IO CString
contentSnifferSniff ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSniffer a, Soup.Message.IsMessage b) =>
a
-> b
-> Soup.Buffer.Buffer
-> m ((T.Text, Map.Map T.Text T.Text))
contentSnifferSniff :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContentSniffer a, IsMessage b) =>
a -> b -> Buffer -> m (Text, Map Text Text)
contentSnifferSniff a
sniffer b
msg Buffer
buffer = IO (Text, Map Text Text) -> m (Text, Map Text Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Map Text Text) -> m (Text, Map Text Text))
-> IO (Text, Map Text Text) -> m (Text, Map Text Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSniffer
sniffer' <- a -> IO (Ptr ContentSniffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sniffer
Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr (Ptr (GHashTable CString CString))
params <- IO (Ptr (Ptr (GHashTable CString CString)))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
CString
result <- Ptr ContentSniffer
-> Ptr Message
-> Ptr Buffer
-> Ptr (Ptr (GHashTable CString CString))
-> IO CString
soup_content_sniffer_sniff Ptr ContentSniffer
sniffer' Ptr Message
msg' Ptr Buffer
buffer' Ptr (Ptr (GHashTable CString CString))
params
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSnifferSniff" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr (GHashTable CString CString)
params' <- Ptr (Ptr (GHashTable CString CString))
-> IO (Ptr (GHashTable CString CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GHashTable CString CString))
params
[(PtrWrapped CString, PtrWrapped CString)]
params'' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
params'
let params''' :: [(CString, PtrWrapped CString)]
params''' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
params''
[(Text, PtrWrapped CString)]
params'''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
params'''
let params''''' :: [(Text, CString)]
params''''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
params''''
[(Text, Text)]
params'''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
params'''''
let params''''''' :: Map Text Text
params''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
params''''''
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
params'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sniffer
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr (Ptr (GHashTable CString CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GHashTable CString CString))
params
(Text, Map Text Text) -> IO (Text, Map Text Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Map Text Text
params''''''')
#if defined(ENABLE_OVERLOADING)
data ContentSnifferSniffMethodInfo
instance (signature ~ (b -> Soup.Buffer.Buffer -> m ((T.Text, Map.Map T.Text T.Text))), MonadIO m, IsContentSniffer a, Soup.Message.IsMessage b) => O.OverloadedMethod ContentSnifferSniffMethodInfo a signature where
overloadedMethod = contentSnifferSniff
instance O.OverloadedMethodInfo ContentSnifferSniffMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Objects.ContentSniffer.contentSnifferSniff",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Objects-ContentSniffer.html#v:contentSnifferSniff"
})
#endif